// @generated by antlr-rust-codegen v0.29.0 - do not edit
// project: https://github.com/ophi-dev/antlr-rust-runtime
antlr4_runtime::__antlr4_rust_require_codegen_api!(6, "0.29.0");
#[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)]
#[rustfmt::skip]
mod __antlr4_rust_generated {

use antlr4_runtime::token::TokenSource;
use antlr4_runtime::token_stream::CommonTokenStream;
use antlr4_runtime::atn::parser_atn::ParserAtn;
use antlr4_runtime::{BaseParser, GrammarMetadata, Parser, Recognizer};
use std::sync::OnceLock;
#[allow(unused_imports)]
use std::io::Write as _;
#[allow(unused_imports)]
use antlr4_runtime::{java_style_list, PredictionMode, BailErrorStrategy, TerminalNodeView as RuntimeTerminalNode, ErrorNodeView as RuntimeErrorNode, RuleNodeView, AsRuleNode, FromRuleNode, MissingChildError, Token as _};


pub const EOF: i32 = antlr4_runtime::TOKEN_EOF;
pub const INTERPOLATED_TEXT: i32 = 1;
pub const XML_TEXT_LIT: i32 = 2;
pub const KW_REFVALUE: i32 = 3;
pub const KW_DESCENDING: i32 = 4;
pub const KW_STACKALLOC: i32 = 5;
pub const KW_ARGLIST: i32 = 6;
pub const KW_MAKEREF: i32 = 7;
pub const KW_REFTYPE: i32 = 8;
pub const KW_ASCENDING: i32 = 9;
pub const KW_EXTENSION: i32 = 10;
pub const KW_INTERFACE: i32 = 11;
pub const KW_NAMESPACE: i32 = 12;
pub const KW_PROTECTED: i32 = 13;
pub const KW_UNCHECKED: i32 = 14;
pub const KW_UNMANAGED: i32 = 15;
pub const KW_ABSTRACT: i32 = 16;
pub const KW_CONTINUE: i32 = 17;
pub const KW_DELEGATE: i32 = 18;
pub const KW_EXPLICIT: i32 = 19;
pub const KW_IMPLICIT: i32 = 20;
pub const KW_INTERNAL: i32 = 21;
pub const KW_OPERATOR: i32 = 22;
pub const KW_OVERRIDE: i32 = 23;
pub const KW_READONLY: i32 = 24;
pub const KW_REQUIRED: i32 = 25;
pub const KW_VOLATILE: i32 = 26;
pub const KW_CHECKED: i32 = 27;
pub const KW_DECIMAL: i32 = 28;
pub const KW_DEFAULT: i32 = 29;
pub const KW_FINALLY: i32 = 30;
pub const KW_FOREACH: i32 = 31;
pub const KW_MANAGED: i32 = 32;
pub const KW_ORDERBY: i32 = 33;
pub const KW_PARTIAL: i32 = 34;
pub const KW_PRIVATE: i32 = 35;
pub const KW_VIRTUAL: i32 = 36;
pub const KW_ALLOWS: i32 = 37;
pub const KW_CLOSED: i32 = 38;
pub const KW_DOUBLE: i32 = 39;
pub const KW_EQUALS: i32 = 40;
pub const KW_EXTERN: i32 = 41;
pub const KW_GLOBAL: i32 = 42;
pub const KW_OBJECT: i32 = 43;
pub const KW_PARAMS: i32 = 44;
pub const KW_PUBLIC: i32 = 45;
pub const KW_REMOVE: i32 = 46;
pub const KW_RETURN: i32 = 47;
pub const KW_SCOPED: i32 = 48;
pub const KW_SEALED: i32 = 49;
pub const KW_SELECT: i32 = 50;
pub const KW_SIZEOF: i32 = 51;
pub const KW_STATIC: i32 = 52;
pub const KW_STRING: i32 = 53;
pub const KW_STRUCT: i32 = 54;
pub const KW_SWITCH: i32 = 55;
pub const KW_TYPEOF: i32 = 56;
pub const KW_UNSAFE: i32 = 57;
pub const KW_USHORT: i32 = 58;
pub const KW_ALIAS: i32 = 59;
pub const KW_ASYNC: i32 = 60;
pub const KW_AWAIT: i32 = 61;
pub const KW_BREAK: i32 = 62;
pub const KW_CATCH: i32 = 63;
pub const KW_CLASS: i32 = 64;
pub const KW_CONST: i32 = 65;
pub const KW_EVENT: i32 = 66;
pub const KW_FALSE: i32 = 67;
pub const KW_FIELD: i32 = 68;
pub const KW_FIXED: i32 = 69;
pub const KW_FLOAT: i32 = 70;
pub const KW_GROUP: i32 = 71;
pub const KW_SBYTE: i32 = 72;
pub const KW_SHORT: i32 = 73;
pub const KW_THROW: i32 = 74;
pub const KW_ULONG: i32 = 75;
pub const KW_UNION: i32 = 76;
pub const KW_USING: i32 = 77;
pub const KW_WHERE: i32 = 78;
pub const KW_WHILE: i32 = 79;
pub const KW_YIELD: i32 = 80;
pub const KW_BASE: i32 = 81;
pub const KW_BOOL: i32 = 82;
pub const KW_BYTE: i32 = 83;
pub const KW_CASE: i32 = 84;
pub const KW_CHAR: i32 = 85;
pub const KW_ELSE: i32 = 86;
pub const KW_ENUM: i32 = 87;
pub const KW_FILE: i32 = 88;
pub const KW_FROM: i32 = 89;
pub const KW_GOTO: i32 = 90;
pub const KW_INIT: i32 = 91;
pub const KW_INTO: i32 = 92;
pub const KW_JOIN: i32 = 93;
pub const KW_LOCK: i32 = 94;
pub const KW_LONG: i32 = 95;
pub const KW_NULL: i32 = 96;
pub const KW_SAFE: i32 = 97;
pub const KW_THIS: i32 = 98;
pub const KW_TRUE: i32 = 99;
pub const KW_UINT: i32 = 100;
pub const KW_VOID: i32 = 101;
pub const KW_WHEN: i32 = 102;
pub const KW_WITH: i32 = 103;
pub const TRIPLE_DQUOTE: i32 = 104;
pub const LT_LT_EQ: i32 = 105;
pub const QUESTION_QUESTION_EQ: i32 = 106;
pub const KW_ADD: i32 = 107;
pub const KW_AND: i32 = 108;
pub const KW_FOR: i32 = 109;
pub const KW_GET: i32 = 110;
pub const KW_INT: i32 = 111;
pub const KW_LET: i32 = 112;
pub const KW_NEW: i32 = 113;
pub const KW_NOT: i32 = 114;
pub const KW_OUT: i32 = 115;
pub const KW_REF: i32 = 116;
pub const KW_SET: i32 = 117;
pub const KW_TRY: i32 = 118;
pub const KW_VAR: i32 = 119;
pub const NE: i32 = 120;
pub const PERCENT_EQ: i32 = 121;
pub const AMP_AMP: i32 = 122;
pub const AMP_EQ: i32 = 123;
pub const STAR_EQ: i32 = 124;
pub const PLUS_PLUS: i32 = 125;
pub const PLUS_EQ: i32 = 126;
pub const MINUS_MINUS: i32 = 127;
pub const MINUS_EQ: i32 = 128;
pub const MINUS_GT: i32 = 129;
pub const DOT_DOT: i32 = 130;
pub const SLASH_EQ: i32 = 131;
pub const SLASH_GT: i32 = 132;
pub const COLON_COLON: i32 = 133;
pub const LT_SLASH: i32 = 134;
pub const LT_LT: i32 = 135;
pub const LE: i32 = 136;
pub const EQ_EQ: i32 = 137;
pub const ARROW: i32 = 138;
pub const GE: i32 = 139;
pub const QUESTION_QUESTION: i32 = 140;
pub const KW_U8: i32 = 141;
pub const ESCAPED_QUOTE: i32 = 142;
pub const ESCAPED_BACKSLASH: i32 = 143;
pub const CARET_EQ: i32 = 144;
pub const KW_AS: i32 = 145;
pub const KW_BY: i32 = 146;
pub const KW_DO: i32 = 147;
pub const KW_IF: i32 = 148;
pub const KW_IN: i32 = 149;
pub const KW_IS: i32 = 150;
pub const KW_ON: i32 = 151;
pub const KW_OR: i32 = 152;
pub const KW_U8_LOWER: i32 = 153;
pub const PIPE_EQ: i32 = 154;
pub const PIPE_PIPE: i32 = 155;
pub const BANG: i32 = 156;
pub const DQUOTE: i32 = 157;
pub const HASH: i32 = 158;
pub const PERCENT: i32 = 159;
pub const AMP: i32 = 160;
pub const STAR: i32 = 161;
pub const PLUS: i32 = 162;
pub const COMMA: i32 = 163;
pub const MINUS: i32 = 164;
pub const DOT: i32 = 165;
pub const SLASH: i32 = 166;
pub const SEMICOLON: i32 = 167;
pub const LT: i32 = 168;
pub const EQ: i32 = 169;
pub const GT: i32 = 170;
pub const QUESTION: i32 = 171;
pub const CARET: i32 = 172;
pub const KW: i32 = 173;
pub const PIPE: i32 = 174;
pub const TILDE: i32 = 175;
pub const KW_RECORD: i32 = 176;
pub const IDENTIFIER: i32 = 177;
pub const DEC_INT_LIT: i32 = 178;
pub const HEX_INT_LIT: i32 = 179;
pub const BIN_INT_LIT: i32 = 180;
pub const REAL_LIT: i32 = 181;
pub const CHAR_LIT: i32 = 182;
pub const STRING_LIT: i32 = 183;
pub const VERBATIM_STRING_LIT: i32 = 184;
pub const SL_RAW_STRING_LIT: i32 = 185;
pub const ML_RAW_STRING_LIT: i32 = 186;
pub const SINGLE_LINE_DOC_COMMENT: i32 = 187;
pub const DELIMITED_DOC_COMMENT: i32 = 188;
pub const SINGLE_LINE_COMMENT: i32 = 189;
pub const DELIMITED_COMMENT: i32 = 190;
pub const WHITESPACES: i32 = 191;
pub const BYTE_ORDER_MARK: i32 = 192;
pub const DIRECTIVE_LINE: i32 = 193;
pub const INTERP_START: i32 = 194;
pub const INTERP_VERBATIM_START: i32 = 195;
pub const INTERP_RAW_START: i32 = 196;
pub const LBRACE: i32 = 197;
pub const RBRACE: i32 = 198;
pub const COLON: i32 = 199;
pub const LPAREN: i32 = 200;
pub const RPAREN: i32 = 201;
pub const LBRACKET: i32 = 202;
pub const RBRACKET: i32 = 203;
pub const INTERP_ESCAPED_OPEN: i32 = 204;
pub const INTERP_ESCAPED_CLOSE: i32 = 205;
pub const INTERP_V_ESCAPED_QUOTE: i32 = 206;

pub const RULE_COMPILATION_UNIT: usize = 0;
pub const RULE_EXTERN_ALIAS_DIRECTIVE: usize = 1;
pub const RULE_USING_DIRECTIVE: usize = 2;
pub const RULE_NAME_EQUALS: usize = 3;
pub const RULE_IDENTIFIER_NAME: usize = 4;
pub const RULE_ATTRIBUTE_LIST: usize = 5;
pub const RULE_ATTRIBUTE_TARGET_SPECIFIER: usize = 6;
pub const RULE_ATTRIBUTE: usize = 7;
pub const RULE_NAME: usize = 8;
pub const RULE_ALIAS_QUALIFIED_NAME: usize = 9;
pub const RULE_SIMPLE_NAME: usize = 10;
pub const RULE_GENERIC_NAME: usize = 11;
pub const RULE_TYPE_ARGUMENT_LIST: usize = 12;
pub const RULE_ATTRIBUTE_ARGUMENT_LIST: usize = 13;
pub const RULE_ATTRIBUTE_ARGUMENT: usize = 14;
pub const RULE_NAME_COLON: usize = 15;
pub const RULE_MEMBER_DECLARATION: usize = 16;
pub const RULE_BASE_FIELD_DECLARATION: usize = 17;
pub const RULE_EVENT_FIELD_DECLARATION: usize = 18;
pub const RULE_MODIFIER: usize = 19;
pub const RULE_VARIABLE_DECLARATION: usize = 20;
pub const RULE_VARIABLE_DECLARATOR: usize = 21;
pub const RULE_BRACKETED_ARGUMENT_LIST: usize = 22;
pub const RULE_ARGUMENT: usize = 23;
pub const RULE_EQUALS_VALUE_CLAUSE: usize = 24;
pub const RULE_FIELD_DECLARATION: usize = 25;
pub const RULE_BASE_METHOD_DECLARATION: usize = 26;
pub const RULE_CONSTRUCTOR_DECLARATION: usize = 27;
pub const RULE_PARAMETER_LIST: usize = 28;
pub const RULE_PARAMETER: usize = 29;
pub const RULE_CONSTRUCTOR_INITIALIZER: usize = 30;
pub const RULE_ARGUMENT_LIST: usize = 31;
pub const RULE_BLOCK: usize = 32;
pub const RULE_ARROW_EXPRESSION_CLAUSE: usize = 33;
pub const RULE_CONVERSION_OPERATOR_DECLARATION: usize = 34;
pub const RULE_EXPLICIT_INTERFACE_SPECIFIER: usize = 35;
pub const RULE_DESTRUCTOR_DECLARATION: usize = 36;
pub const RULE_METHOD_DECLARATION: usize = 37;
pub const RULE_TYPE_PARAMETER_LIST: usize = 38;
pub const RULE_TYPE_PARAMETER: usize = 39;
pub const RULE_TYPE_PARAMETER_CONSTRAINT_CLAUSE: usize = 40;
pub const RULE_TYPE_PARAMETER_CONSTRAINT: usize = 41;
pub const RULE_ALLOWS_CONSTRAINT_CLAUSE: usize = 42;
pub const RULE_ALLOWS_CONSTRAINT: usize = 43;
pub const RULE_REF_STRUCT_CONSTRAINT: usize = 44;
pub const RULE_CLASS_OR_STRUCT_CONSTRAINT: usize = 45;
pub const RULE_CONSTRUCTOR_CONSTRAINT: usize = 46;
pub const RULE_DEFAULT_CONSTRAINT: usize = 47;
pub const RULE_TYPE_CONSTRAINT: usize = 48;
pub const RULE_OPERATOR_DECLARATION: usize = 49;
pub const RULE_BASE_NAMESPACE_DECLARATION: usize = 50;
pub const RULE_FILE_SCOPED_NAMESPACE_DECLARATION: usize = 51;
pub const RULE_NAMESPACE_DECLARATION: usize = 52;
pub const RULE_BASE_PROPERTY_DECLARATION: usize = 53;
pub const RULE_EVENT_DECLARATION: usize = 54;
pub const RULE_ACCESSOR_LIST: usize = 55;
pub const RULE_ACCESSOR_DECLARATION: usize = 56;
pub const RULE_INDEXER_DECLARATION: usize = 57;
pub const RULE_BRACKETED_PARAMETER_LIST: usize = 58;
pub const RULE_PROPERTY_DECLARATION: usize = 59;
pub const RULE_BASE_TYPE_DECLARATION: usize = 60;
pub const RULE_ENUM_DECLARATION: usize = 61;
pub const RULE_BASE_LIST: usize = 62;
pub const RULE_BASE_TYPE: usize = 63;
pub const RULE_PRIMARY_CONSTRUCTOR_BASE_TYPE: usize = 64;
pub const RULE_SIMPLE_BASE_TYPE: usize = 65;
pub const RULE_ENUM_MEMBER_DECLARATION: usize = 66;
pub const RULE_TYPE_DECLARATION: usize = 67;
pub const RULE_CLASS_DECLARATION: usize = 68;
pub const RULE_EXTENSION_BLOCK_DECLARATION: usize = 69;
pub const RULE_INTERFACE_DECLARATION: usize = 70;
pub const RULE_RECORD_DECLARATION: usize = 71;
pub const RULE_STRUCT_DECLARATION: usize = 72;
pub const RULE_UNION_DECLARATION: usize = 73;
pub const RULE_DELEGATE_DECLARATION: usize = 74;
pub const RULE_GLOBAL_STATEMENT: usize = 75;
pub const RULE_TYPE: usize = 76;
pub const RULE_ARRAY_TYPE: usize = 77;
pub const RULE_ARRAY_RANK_SPECIFIER: usize = 78;
pub const RULE_FUNCTION_POINTER_TYPE: usize = 79;
pub const RULE_FUNCTION_POINTER_CALLING_CONVENTION: usize = 80;
pub const RULE_FUNCTION_POINTER_UNMANAGED_CALLING_CONVENTION_LIST: usize = 81;
pub const RULE_FUNCTION_POINTER_UNMANAGED_CALLING_CONVENTION: usize = 82;
pub const RULE_FUNCTION_POINTER_PARAMETER_LIST: usize = 83;
pub const RULE_FUNCTION_POINTER_PARAMETER: usize = 84;
pub const RULE_PREDEFINED_TYPE: usize = 85;
pub const RULE_REF_TYPE: usize = 86;
pub const RULE_SCOPED_TYPE: usize = 87;
pub const RULE_TUPLE_TYPE: usize = 88;
pub const RULE_TUPLE_ELEMENT: usize = 89;
pub const RULE_STATEMENT: usize = 90;
pub const RULE_BREAK_STATEMENT: usize = 91;
pub const RULE_CHECKED_STATEMENT: usize = 92;
pub const RULE_COMMON_FOR_EACH_STATEMENT: usize = 93;
pub const RULE_FOR_EACH_STATEMENT: usize = 94;
pub const RULE_FOR_EACH_VARIABLE_STATEMENT: usize = 95;
pub const RULE_CONTINUE_STATEMENT: usize = 96;
pub const RULE_DO_STATEMENT: usize = 97;
pub const RULE_EMPTY_STATEMENT: usize = 98;
pub const RULE_EXPRESSION_STATEMENT: usize = 99;
pub const RULE_FIXED_STATEMENT: usize = 100;
pub const RULE_FOR_STATEMENT: usize = 101;
pub const RULE_GOTO_STATEMENT: usize = 102;
pub const RULE_IF_STATEMENT: usize = 103;
pub const RULE_ELSE_CLAUSE: usize = 104;
pub const RULE_LABELED_STATEMENT: usize = 105;
pub const RULE_LOCAL_DECLARATION_STATEMENT: usize = 106;
pub const RULE_LOCAL_FUNCTION_STATEMENT: usize = 107;
pub const RULE_LOCK_STATEMENT: usize = 108;
pub const RULE_RETURN_STATEMENT: usize = 109;
pub const RULE_SWITCH_STATEMENT: usize = 110;
pub const RULE_SWITCH_SECTION: usize = 111;
pub const RULE_SWITCH_LABEL: usize = 112;
pub const RULE_CASE_PATTERN_SWITCH_LABEL: usize = 113;
pub const RULE_PATTERN: usize = 114;
pub const RULE_CONSTANT_PATTERN: usize = 115;
pub const RULE_DECLARATION_PATTERN: usize = 116;
pub const RULE_VARIABLE_DESIGNATION: usize = 117;
pub const RULE_DISCARD_DESIGNATION: usize = 118;
pub const RULE_PARENTHESIZED_VARIABLE_DESIGNATION: usize = 119;
pub const RULE_SINGLE_VARIABLE_DESIGNATION: usize = 120;
pub const RULE_DISCARD_PATTERN: usize = 121;
pub const RULE_LIST_PATTERN: usize = 122;
pub const RULE_PARENTHESIZED_PATTERN: usize = 123;
pub const RULE_RECURSIVE_PATTERN: usize = 124;
pub const RULE_POSITIONAL_PATTERN_CLAUSE: usize = 125;
pub const RULE_SUBPATTERN: usize = 126;
pub const RULE_BASE_EXPRESSION_COLON: usize = 127;
pub const RULE_EXPRESSION_COLON: usize = 128;
pub const RULE_PROPERTY_PATTERN_CLAUSE: usize = 129;
pub const RULE_RELATIONAL_PATTERN: usize = 130;
pub const RULE_SLICE_PATTERN: usize = 131;
pub const RULE_TYPE_PATTERN: usize = 132;
pub const RULE_UNARY_PATTERN: usize = 133;
pub const RULE_VAR_PATTERN: usize = 134;
pub const RULE_WHEN_CLAUSE: usize = 135;
pub const RULE_CASE_SWITCH_LABEL: usize = 136;
pub const RULE_DEFAULT_SWITCH_LABEL: usize = 137;
pub const RULE_THROW_STATEMENT: usize = 138;
pub const RULE_TRY_STATEMENT: usize = 139;
pub const RULE_CATCH_CLAUSE: usize = 140;
pub const RULE_CATCH_DECLARATION: usize = 141;
pub const RULE_CATCH_FILTER_CLAUSE: usize = 142;
pub const RULE_FINALLY_CLAUSE: usize = 143;
pub const RULE_UNSAFE_STATEMENT: usize = 144;
pub const RULE_USING_STATEMENT: usize = 145;
pub const RULE_WHILE_STATEMENT: usize = 146;
pub const RULE_YIELD_STATEMENT: usize = 147;
pub const RULE_EXPRESSION: usize = 148;
pub const RULE_ANONYMOUS_FUNCTION_EXPRESSION: usize = 149;
pub const RULE_ANONYMOUS_METHOD_EXPRESSION: usize = 150;
pub const RULE_LAMBDA_EXPRESSION: usize = 151;
pub const RULE_PARENTHESIZED_LAMBDA_EXPRESSION: usize = 152;
pub const RULE_SIMPLE_LAMBDA_EXPRESSION: usize = 153;
pub const RULE_ANONYMOUS_OBJECT_CREATION_EXPRESSION: usize = 154;
pub const RULE_ANONYMOUS_OBJECT_MEMBER_DECLARATOR: usize = 155;
pub const RULE_ARRAY_CREATION_EXPRESSION: usize = 156;
pub const RULE_INITIALIZER_EXPRESSION: usize = 157;
pub const RULE_AWAIT_EXPRESSION: usize = 158;
pub const RULE_BASE_OBJECT_CREATION_EXPRESSION: usize = 159;
pub const RULE_IMPLICIT_OBJECT_CREATION_EXPRESSION: usize = 160;
pub const RULE_OBJECT_CREATION_EXPRESSION: usize = 161;
pub const RULE_CAST_EXPRESSION: usize = 162;
pub const RULE_CHECKED_EXPRESSION: usize = 163;
pub const RULE_COLLECTION_EXPRESSION: usize = 164;
pub const RULE_COLLECTION_ELEMENT: usize = 165;
pub const RULE_EXPRESSION_ELEMENT: usize = 166;
pub const RULE_SPREAD_ELEMENT: usize = 167;
pub const RULE_WITH_ELEMENT: usize = 168;
pub const RULE_DECLARATION_EXPRESSION: usize = 169;
pub const RULE_DEFAULT_EXPRESSION: usize = 170;
pub const RULE_ELEMENT_BINDING_EXPRESSION: usize = 171;
pub const RULE_FIELD_EXPRESSION: usize = 172;
pub const RULE_IMPLICIT_ARRAY_CREATION_EXPRESSION: usize = 173;
pub const RULE_IMPLICIT_ELEMENT_ACCESS: usize = 174;
pub const RULE_IMPLICIT_STACK_ALLOC_ARRAY_CREATION_EXPRESSION: usize = 175;
pub const RULE_INSTANCE_EXPRESSION: usize = 176;
pub const RULE_BASE_EXPRESSION: usize = 177;
pub const RULE_THIS_EXPRESSION: usize = 178;
pub const RULE_INTERPOLATED_STRING_EXPRESSION: usize = 179;
pub const RULE_INTERPOLATED_STRING_CONTENT: usize = 180;
pub const RULE_INTERPOLATED_STRING_TEXT: usize = 181;
pub const RULE_INTERPOLATION: usize = 182;
pub const RULE_INTERPOLATION_ALIGNMENT_CLAUSE: usize = 183;
pub const RULE_INTERPOLATION_FORMAT_CLAUSE: usize = 184;
pub const RULE_INTERPOLATED_MULTI_LINE_RAW_STRING_START_TOKEN: usize = 185;
pub const RULE_INTERPOLATED_RAW_STRING_END_TOKEN: usize = 186;
pub const RULE_INTERPOLATED_SINGLE_LINE_RAW_STRING_START_TOKEN: usize = 187;
pub const RULE_LITERAL_EXPRESSION: usize = 188;
pub const RULE_UTF8_MULTI_LINE_RAW_STRING_LITERAL_TOKEN: usize = 189;
pub const RULE_UTF8_SINGLE_LINE_RAW_STRING_LITERAL_TOKEN: usize = 190;
pub const RULE_UTF8_STRING_LITERAL_TOKEN: usize = 191;
pub const RULE_MAKE_REF_EXPRESSION: usize = 192;
pub const RULE_MEMBER_BINDING_EXPRESSION: usize = 193;
pub const RULE_PARENTHESIZED_EXPRESSION: usize = 194;
pub const RULE_PREFIX_UNARY_EXPRESSION: usize = 195;
pub const RULE_QUERY_EXPRESSION: usize = 196;
pub const RULE_FROM_CLAUSE: usize = 197;
pub const RULE_QUERY_BODY: usize = 198;
pub const RULE_QUERY_CLAUSE: usize = 199;
pub const RULE_JOIN_CLAUSE: usize = 200;
pub const RULE_JOIN_INTO_CLAUSE: usize = 201;
pub const RULE_LET_CLAUSE: usize = 202;
pub const RULE_ORDER_BY_CLAUSE: usize = 203;
pub const RULE_ORDERING: usize = 204;
pub const RULE_WHERE_CLAUSE: usize = 205;
pub const RULE_SELECT_OR_GROUP_CLAUSE: usize = 206;
pub const RULE_GROUP_CLAUSE: usize = 207;
pub const RULE_SELECT_CLAUSE: usize = 208;
pub const RULE_QUERY_CONTINUATION: usize = 209;
pub const RULE_REF_EXPRESSION: usize = 210;
pub const RULE_REF_TYPE_EXPRESSION: usize = 211;
pub const RULE_REF_VALUE_EXPRESSION: usize = 212;
pub const RULE_SIZE_OF_EXPRESSION: usize = 213;
pub const RULE_STACK_ALLOC_ARRAY_CREATION_EXPRESSION: usize = 214;
pub const RULE_SWITCH_EXPRESSION_ARM: usize = 215;
pub const RULE_THROW_EXPRESSION: usize = 216;
pub const RULE_TUPLE_EXPRESSION: usize = 217;
pub const RULE_TYPE_OF_EXPRESSION: usize = 218;
pub const RULE_UNSAFE_EXPRESSION: usize = 219;
pub const RULE_SYNTAX_TOKEN: usize = 220;
pub const RULE_IDENTIFIER_TOKEN: usize = 221;
pub const RULE_KEYWORD: usize = 222;
pub const RULE_NUMERIC_LITERAL_TOKEN: usize = 223;
pub const RULE_INTEGER_LITERAL_TOKEN: usize = 224;
pub const RULE_DECIMAL_INTEGER_LITERAL_TOKEN: usize = 225;
pub const RULE_HEXADECIMAL_INTEGER_LITERAL_TOKEN: usize = 226;
pub const RULE_REAL_LITERAL_TOKEN: usize = 227;
pub const RULE_CHARACTER_LITERAL_TOKEN: usize = 228;
pub const RULE_STRING_LITERAL_TOKEN: usize = 229;
pub const RULE_REGULAR_STRING_LITERAL_TOKEN: usize = 230;
pub const RULE_VERBATIM_STRING_LITERAL_TOKEN: usize = 231;
pub const RULE_OPERATOR_TOKEN: usize = 232;
pub const RULE_PUNCTUATION_TOKEN: usize = 233;
pub const RULE_INTERPOLATED_STRING_TEXT_TOKEN: usize = 234;
pub const RULE_MULTI_LINE_RAW_STRING_LITERAL_TOKEN: usize = 235;
pub const RULE_SINGLE_LINE_RAW_STRING_LITERAL_TOKEN: usize = 236;
pub const RULE_RECORD_KEYWORD: usize = 237;
pub const RULE_RIGHT_SHIFT: usize = 238;
pub const RULE_UNSIGNED_RIGHT_SHIFT: usize = 239;
pub const RULE_RIGHT_SHIFT_ASSIGNMENT: usize = 240;
pub const RULE_UNSIGNED_RIGHT_SHIFT_ASSIGNMENT: usize = 241;
pub const RULE_LOCAL_VARIABLE_DECLARATION: usize = 242;
pub const RULE_LOCAL_VARIABLE_DECLARATOR: usize = 243;

pub static METADATA: GrammarMetadata = GrammarMetadata::new(
    "CSharpParser",
    &["compilation_unit", "extern_alias_directive", "using_directive", "name_equals", "identifier_name", "attribute_list", "attribute_target_specifier", "attribute", "name", "alias_qualified_name", "simple_name", "generic_name", "type_argument_list", "attribute_argument_list", "attribute_argument", "name_colon", "member_declaration", "base_field_declaration", "event_field_declaration", "modifier", "variable_declaration", "variable_declarator", "bracketed_argument_list", "argument", "equals_value_clause", "field_declaration", "base_method_declaration", "constructor_declaration", "parameter_list", "parameter", "constructor_initializer", "argument_list", "block", "arrow_expression_clause", "conversion_operator_declaration", "explicit_interface_specifier", "destructor_declaration", "method_declaration", "type_parameter_list", "type_parameter", "type_parameter_constraint_clause", "type_parameter_constraint", "allows_constraint_clause", "allows_constraint", "ref_struct_constraint", "class_or_struct_constraint", "constructor_constraint", "default_constraint", "type_constraint", "operator_declaration", "base_namespace_declaration", "file_scoped_namespace_declaration", "namespace_declaration", "base_property_declaration", "event_declaration", "accessor_list", "accessor_declaration", "indexer_declaration", "bracketed_parameter_list", "property_declaration", "base_type_declaration", "enum_declaration", "base_list", "base_type", "primary_constructor_base_type", "simple_base_type", "enum_member_declaration", "type_declaration", "class_declaration", "extension_block_declaration", "interface_declaration", "record_declaration", "struct_declaration", "union_declaration", "delegate_declaration", "global_statement", "type", "array_type", "array_rank_specifier", "function_pointer_type", "function_pointer_calling_convention", "function_pointer_unmanaged_calling_convention_list", "function_pointer_unmanaged_calling_convention", "function_pointer_parameter_list", "function_pointer_parameter", "predefined_type", "ref_type", "scoped_type", "tuple_type", "tuple_element", "statement", "break_statement", "checked_statement", "common_for_each_statement", "for_each_statement", "for_each_variable_statement", "continue_statement", "do_statement", "empty_statement", "expression_statement", "fixed_statement", "for_statement", "goto_statement", "if_statement", "else_clause", "labeled_statement", "local_declaration_statement", "local_function_statement", "lock_statement", "return_statement", "switch_statement", "switch_section", "switch_label", "case_pattern_switch_label", "pattern", "constant_pattern", "declaration_pattern", "variable_designation", "discard_designation", "parenthesized_variable_designation", "single_variable_designation", "discard_pattern", "list_pattern", "parenthesized_pattern", "recursive_pattern", "positional_pattern_clause", "subpattern", "base_expression_colon", "expression_colon", "property_pattern_clause", "relational_pattern", "slice_pattern", "type_pattern", "unary_pattern", "var_pattern", "when_clause", "case_switch_label", "default_switch_label", "throw_statement", "try_statement", "catch_clause", "catch_declaration", "catch_filter_clause", "finally_clause", "unsafe_statement", "using_statement", "while_statement", "yield_statement", "expression", "anonymous_function_expression", "anonymous_method_expression", "lambda_expression", "parenthesized_lambda_expression", "simple_lambda_expression", "anonymous_object_creation_expression", "anonymous_object_member_declarator", "array_creation_expression", "initializer_expression", "await_expression", "base_object_creation_expression", "implicit_object_creation_expression", "object_creation_expression", "cast_expression", "checked_expression", "collection_expression", "collection_element", "expression_element", "spread_element", "with_element", "declaration_expression", "default_expression", "element_binding_expression", "field_expression", "implicit_array_creation_expression", "implicit_element_access", "implicit_stack_alloc_array_creation_expression", "instance_expression", "base_expression", "this_expression", "interpolated_string_expression", "interpolated_string_content", "interpolated_string_text", "interpolation", "interpolation_alignment_clause", "interpolation_format_clause", "interpolated_multi_line_raw_string_start_token", "interpolated_raw_string_end_token", "interpolated_single_line_raw_string_start_token", "literal_expression", "utf8_multi_line_raw_string_literal_token", "utf8_single_line_raw_string_literal_token", "utf8_string_literal_token", "make_ref_expression", "member_binding_expression", "parenthesized_expression", "prefix_unary_expression", "query_expression", "from_clause", "query_body", "query_clause", "join_clause", "join_into_clause", "let_clause", "order_by_clause", "ordering", "where_clause", "select_or_group_clause", "group_clause", "select_clause", "query_continuation", "ref_expression", "ref_type_expression", "ref_value_expression", "size_of_expression", "stack_alloc_array_creation_expression", "switch_expression_arm", "throw_expression", "tuple_expression", "type_of_expression", "unsafe_expression", "syntax_token", "identifier_token", "keyword", "numeric_literal_token", "integer_literal_token", "decimal_integer_literal_token", "hexadecimal_integer_literal_token", "real_literal_token", "character_literal_token", "string_literal_token", "regular_string_literal_token", "verbatim_string_literal_token", "operator_token", "punctuation_token", "interpolated_string_text_token", "multi_line_raw_string_literal_token", "single_line_raw_string_literal_token", "record_keyword", "right_shift", "unsigned_right_shift", "right_shift_assignment", "unsigned_right_shift_assignment", "local_variable_declaration", "local_variable_declarator"],
    &[None, None, None, Some("\'__refvalue\'"), Some("\'descending\'"), Some("\'stackalloc\'"), Some("\'__arglist\'"), Some("\'__makeref\'"), Some("\'__reftype\'"), Some("\'ascending\'"), Some("\'extension\'"), Some("\'interface\'"), Some("\'namespace\'"), Some("\'protected\'"), Some("\'unchecked\'"), Some("\'unmanaged\'"), Some("\'abstract\'"), Some("\'continue\'"), Some("\'delegate\'"), Some("\'explicit\'"), Some("\'implicit\'"), Some("\'internal\'"), Some("\'operator\'"), Some("\'override\'"), Some("\'readonly\'"), Some("\'required\'"), Some("\'volatile\'"), Some("\'checked\'"), Some("\'decimal\'"), Some("\'default\'"), Some("\'finally\'"), Some("\'foreach\'"), Some("\'managed\'"), Some("\'orderby\'"), Some("\'partial\'"), Some("\'private\'"), Some("\'virtual\'"), Some("\'allows\'"), Some("\'closed\'"), Some("\'double\'"), Some("\'equals\'"), Some("\'extern\'"), Some("\'global\'"), Some("\'object\'"), Some("\'params\'"), Some("\'public\'"), Some("\'remove\'"), Some("\'return\'"), Some("\'scoped\'"), Some("\'sealed\'"), Some("\'select\'"), Some("\'sizeof\'"), Some("\'static\'"), Some("\'string\'"), Some("\'struct\'"), Some("\'switch\'"), Some("\'typeof\'"), Some("\'unsafe\'"), Some("\'ushort\'"), Some("\'alias\'"), Some("\'async\'"), Some("\'await\'"), Some("\'break\'"), Some("\'catch\'"), Some("\'class\'"), Some("\'const\'"), Some("\'event\'"), Some("\'false\'"), Some("\'field\'"), Some("\'fixed\'"), Some("\'float\'"), Some("\'group\'"), Some("\'sbyte\'"), Some("\'short\'"), Some("\'throw\'"), Some("\'ulong\'"), Some("\'union\'"), Some("\'using\'"), Some("\'where\'"), Some("\'while\'"), Some("\'yield\'"), Some("\'base\'"), Some("\'bool\'"), Some("\'byte\'"), Some("\'case\'"), Some("\'char\'"), Some("\'else\'"), Some("\'enum\'"), Some("\'file\'"), Some("\'from\'"), Some("\'goto\'"), Some("\'init\'"), Some("\'into\'"), Some("\'join\'"), Some("\'lock\'"), Some("\'long\'"), Some("\'null\'"), Some("\'safe\'"), Some("\'this\'"), Some("\'true\'"), Some("\'uint\'"), Some("\'void\'"), Some("\'when\'"), Some("\'with\'"), Some("\'\"\"\"\'"), Some("\'<<=\'"), Some("\'??=\'"), Some("\'add\'"), Some("\'and\'"), Some("\'for\'"), Some("\'get\'"), Some("\'int\'"), Some("\'let\'"), Some("\'new\'"), Some("\'not\'"), Some("\'out\'"), Some("\'ref\'"), Some("\'set\'"), Some("\'try\'"), Some("\'var\'"), Some("\'!=\'"), Some("\'%=\'"), Some("\'&&\'"), Some("\'&=\'"), Some("\'*=\'"), Some("\'++\'"), Some("\'+=\'"), Some("\'--\'"), Some("\'-=\'"), Some("\'->\'"), Some("\'..\'"), Some("\'/=\'"), Some("\'/>\'"), Some("\'::\'"), Some("\'</\'"), Some("\'<<\'"), Some("\'<=\'"), Some("\'==\'"), Some("\'=>\'"), Some("\'>=\'"), Some("\'??\'"), Some("\'U8\'"), Some("\'\\\'\'"), Some("\'\\\\\'"), Some("\'^=\'"), Some("\'as\'"), Some("\'by\'"), Some("\'do\'"), Some("\'if\'"), Some("\'in\'"), Some("\'is\'"), Some("\'on\'"), Some("\'or\'"), Some("\'u8\'"), Some("\'|=\'"), Some("\'||\'"), Some("\'!\'"), None, Some("\'#\'"), Some("\'%\'"), Some("\'&\'"), Some("\'*\'"), Some("\'+\'"), Some("\',\'"), Some("\'-\'"), Some("\'.\'"), Some("\'/\'"), Some("\';\'"), Some("\'<\'"), Some("\'=\'"), Some("\'>\'"), Some("\'?\'"), Some("\'^\'"), Some("\'_\'"), Some("\'|\'"), Some("\'~\'"), Some("\'record\'"), None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, Some("\'\u{feff}\'"), None, Some("\'$\"\'"), None, None, None, None, Some("\':\'"), Some("\'(\'"), Some("\')\'"), Some("\'[\'"), Some("\']\'"), None, None, Some("\'\"\"\'")],
    &[None, Some("INTERPOLATED_TEXT"), Some("XML_TEXT_LIT"), Some("KW___REFVALUE"), Some("KW_DESCENDING"), Some("KW_STACKALLOC"), Some("KW___ARGLIST"), Some("KW___MAKEREF"), Some("KW___REFTYPE"), Some("KW_ASCENDING"), Some("KW_EXTENSION"), Some("KW_INTERFACE"), Some("KW_NAMESPACE"), Some("KW_PROTECTED"), Some("KW_UNCHECKED"), Some("KW_UNMANAGED"), Some("KW_ABSTRACT"), Some("KW_CONTINUE"), Some("KW_DELEGATE"), Some("KW_EXPLICIT"), Some("KW_IMPLICIT"), Some("KW_INTERNAL"), Some("KW_OPERATOR"), Some("KW_OVERRIDE"), Some("KW_READONLY"), Some("KW_REQUIRED"), Some("KW_VOLATILE"), Some("KW_CHECKED"), Some("KW_DECIMAL"), Some("KW_DEFAULT"), Some("KW_FINALLY"), Some("KW_FOREACH"), Some("KW_MANAGED"), Some("KW_ORDERBY"), Some("KW_PARTIAL"), Some("KW_PRIVATE"), Some("KW_VIRTUAL"), Some("KW_ALLOWS"), Some("KW_CLOSED"), Some("KW_DOUBLE"), Some("KW_EQUALS"), Some("KW_EXTERN"), Some("KW_GLOBAL"), Some("KW_OBJECT"), Some("KW_PARAMS"), Some("KW_PUBLIC"), Some("KW_REMOVE"), Some("KW_RETURN"), Some("KW_SCOPED"), Some("KW_SEALED"), Some("KW_SELECT"), Some("KW_SIZEOF"), Some("KW_STATIC"), Some("KW_STRING"), Some("KW_STRUCT"), Some("KW_SWITCH"), Some("KW_TYPEOF"), Some("KW_UNSAFE"), Some("KW_USHORT"), Some("KW_ALIAS"), Some("KW_ASYNC"), Some("KW_AWAIT"), Some("KW_BREAK"), Some("KW_CATCH"), Some("KW_CLASS"), Some("KW_CONST"), Some("KW_EVENT"), Some("KW_FALSE"), Some("KW_FIELD"), Some("KW_FIXED"), Some("KW_FLOAT"), Some("KW_GROUP"), Some("KW_SBYTE"), Some("KW_SHORT"), Some("KW_THROW"), Some("KW_ULONG"), Some("KW_UNION"), Some("KW_USING"), Some("KW_WHERE"), Some("KW_WHILE"), Some("KW_YIELD"), Some("KW_BASE"), Some("KW_BOOL"), Some("KW_BYTE"), Some("KW_CASE"), Some("KW_CHAR"), Some("KW_ELSE"), Some("KW_ENUM"), Some("KW_FILE"), Some("KW_FROM"), Some("KW_GOTO"), Some("KW_INIT"), Some("KW_INTO"), Some("KW_JOIN"), Some("KW_LOCK"), Some("KW_LONG"), Some("KW_NULL"), Some("KW_SAFE"), Some("KW_THIS"), Some("KW_TRUE"), Some("KW_UINT"), Some("KW_VOID"), Some("KW_WHEN"), Some("KW_WITH"), Some("TRIPLE_DQUOTE"), Some("LT_LT_EQ"), Some("QUESTION_QUESTION_EQ"), Some("KW_ADD"), Some("KW_AND"), Some("KW_FOR"), Some("KW_GET"), Some("KW_INT"), Some("KW_LET"), Some("KW_NEW"), Some("KW_NOT"), Some("KW_OUT"), Some("KW_REF"), Some("KW_SET"), Some("KW_TRY"), Some("KW_VAR"), Some("NE"), Some("PERCENT_EQ"), Some("AMP_AMP"), Some("AMP_EQ"), Some("STAR_EQ"), Some("PLUS_PLUS"), Some("PLUS_EQ"), Some("MINUS_MINUS"), Some("MINUS_EQ"), Some("MINUS_GT"), Some("DOT_DOT"), Some("SLASH_EQ"), Some("SLASH_GT"), Some("COLON_COLON"), Some("LT_SLASH"), Some("LT_LT"), Some("LE"), Some("EQ_EQ"), Some("ARROW"), Some("GE"), Some("QUESTION_QUESTION"), Some("KW_U8"), Some("ESCAPED_QUOTE"), Some("ESCAPED_BACKSLASH"), Some("CARET_EQ"), Some("KW_AS"), Some("KW_BY"), Some("KW_DO"), Some("KW_IF"), Some("KW_IN"), Some("KW_IS"), Some("KW_ON"), Some("KW_OR"), Some("KW_U8_LOWER"), Some("PIPE_EQ"), Some("PIPE_PIPE"), Some("BANG"), Some("DQUOTE"), Some("HASH"), Some("PERCENT"), Some("AMP"), Some("STAR"), Some("PLUS"), Some("COMMA"), Some("MINUS"), Some("DOT"), Some("SLASH"), Some("SEMICOLON"), Some("LT"), Some("EQ"), Some("GT"), Some("QUESTION"), Some("CARET"), Some("KW__"), Some("PIPE"), Some("TILDE"), Some("KW_RECORD"), Some("IDENTIFIER"), Some("DEC_INT_LIT"), Some("HEX_INT_LIT"), Some("BIN_INT_LIT"), Some("REAL_LIT"), Some("CHAR_LIT"), Some("STRING_LIT"), Some("VERBATIM_STRING_LIT"), Some("SL_RAW_STRING_LIT"), Some("ML_RAW_STRING_LIT"), Some("SINGLE_LINE_DOC_COMMENT"), Some("DELIMITED_DOC_COMMENT"), Some("SINGLE_LINE_COMMENT"), Some("DELIMITED_COMMENT"), Some("WHITESPACES"), Some("BYTE_ORDER_MARK"), Some("DIRECTIVE_LINE"), Some("INTERP_START"), Some("INTERP_VERBATIM_START"), Some("INTERP_RAW_START"), Some("LBRACE"), Some("RBRACE"), Some("COLON"), Some("LPAREN"), Some("RPAREN"), Some("LBRACKET"), Some("RBRACKET"), Some("INTERP_ESCAPED_OPEN"), Some("INTERP_ESCAPED_CLOSE"), Some("INTERP_V_ESCAPED_QUOTE")],
    &[None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None],
    &[],
    &[],
    &[],
);

pub fn metadata() -> &'static GrammarMetadata {
    &METADATA
}

pub fn rule_names() -> &'static [&'static str] {
    METADATA.rule_names()
}

fn parser_semantics() -> &'static antlr4_runtime::ParserSemantics {
    static SEMANTICS_CELL: OnceLock<antlr4_runtime::ParserSemantics> = OnceLock::new();
    SEMANTICS_CELL.get_or_init(|| {
        let mut ir = antlr4_runtime::semir::SemIr::new();
        let mut predicates = Vec::new();
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 238, pred_index: 17, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 239, pred_index: 18, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 239, pred_index: 19, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 240, pred_index: 20, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 241, pred_index: 21, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::TokenIndexAdjacent);
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 241, pred_index: 22, expr: __expr, failure_message: None });

        let actions = Vec::new();
        antlr4_runtime::ParserSemantics { ir, predicates, actions }
    })
}




#[allow(dead_code)]
pub struct __GeneratedInput<'a, L: TokenSource>(&'a mut CommonTokenStream<L>);

#[allow(dead_code)]
impl<L: TokenSource> __GeneratedInput<'_, L> {
    pub fn text(&mut self) -> String {
        self.0.text_all()
    }

    pub fn la(&mut self, offset: isize) -> i32 {
        antlr4_runtime::IntStream::la(self.0, offset)
    }

    pub fn lt(&mut self, offset: isize) -> __GeneratedTokenView {
        __GeneratedTokenView {
            text: self
                .0
                .lt(offset)
                .map(|token| token.text_or_empty().to_owned())
                .unwrap_or_default(),
        }
    }
}

#[allow(dead_code)]
pub struct __GeneratedTokenView {
    text: String,
}

#[allow(dead_code)]
impl __GeneratedTokenView {
    pub fn text(&self) -> &str {
        &self.text
    }
}
#[allow(dead_code)]
#[derive(Clone)]
pub struct TerminalNode<'a> {
    __node: RuntimeTerminalNode<'a>,
}

#[allow(dead_code)]
impl<'a> TerminalNode<'a> {
    fn new(node: RuntimeTerminalNode<'a>) -> Self {
        Self { __node: node }
    }

    pub fn symbol(&self) -> antlr4_runtime::TokenView<'a> {
        self.__node.symbol()
    }

    pub fn is_error(&self) -> bool {
        matches!(
            self.__node.node().kind(),
            antlr4_runtime::NodeKind::Error
        )
    }

    pub fn is_missing(&self) -> bool {
        self.symbol().is_synthetic()
    }
}

impl std::fmt::Display for TerminalNode<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.__node.text())
    }
}

#[allow(dead_code)]
#[derive(Clone)]
pub struct ErrorNode<'a> {
    __node: RuntimeErrorNode<'a>,
}

#[allow(dead_code)]
impl<'a> ErrorNode<'a> {
    fn new(node: RuntimeErrorNode<'a>) -> Self {
        Self { __node: node }
    }

    pub fn symbol(&self) -> antlr4_runtime::TokenView<'a> {
        self.__node.symbol()
    }

    pub fn is_missing(&self) -> bool {
        self.symbol().is_synthetic()
    }
}

impl std::fmt::Display for ErrorNode<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.__node.text())
    }
}

#[allow(dead_code)]
#[derive(Clone, Copy)]
enum __GeneratedRuleContext<'a> {
    Stored(RuleNodeView<'a>),
    Active {
        context: &'a antlr4_runtime::ParserRuleContext,
        storage: &'a antlr4_runtime::ParseTreeStorage,
        tokens: &'a antlr4_runtime::TokenStore,
    },
}

#[doc(hidden)]
#[derive(Clone, Copy, Debug)]
pub struct StoredTreeContext;

#[derive(Clone, Copy, Debug)]
struct __ActiveParserContext;

#[allow(dead_code)]
fn __context_children<'a>(
    source: __GeneratedRuleContext<'a>,
) -> impl Iterator<Item = antlr4_runtime::Node<'a>> + 'a {
    let mut stored = match source {
        __GeneratedRuleContext::Stored(node) => Some(node.children()),
        __GeneratedRuleContext::Active { .. } => None,
    };
    let mut active = match source {
        __GeneratedRuleContext::Stored(_) => None,
        __GeneratedRuleContext::Active {
            context,
            storage,
            tokens,
        } => Some(context.child_nodes(storage, tokens)),
    };
    std::iter::from_fn(move || {
        stored
            .as_mut()
            .and_then(Iterator::next)
            .or_else(|| active.as_mut().and_then(Iterator::next))
    })
}

#[allow(dead_code)]
fn __rule_children<'a>(
    source: __GeneratedRuleContext<'a>,
    rule_index: usize,
) -> impl Iterator<Item = RuleNodeView<'a>> + 'a {
    __context_children(source).filter_map(move |child| {
        let rule = child.as_rule()?;
        (rule.rule_index() == rule_index).then_some(rule)
    })
}

// Keep this triage aligned with runtime `RuleNodeView::terminal_children()` and
// `ParserRuleContext::terminal_children()`.
fn __terminal_children<'a>(
    source: __GeneratedRuleContext<'a>,
) -> impl Iterator<Item = RuntimeTerminalNode<'a>> + 'a {
    __context_children(source).filter_map(|child| match child.kind() {
        antlr4_runtime::NodeKind::Terminal => child.as_terminal(),
        antlr4_runtime::NodeKind::Error => {
            child.as_error().map(antlr4_runtime::ErrorNodeView::terminal)
        }
        antlr4_runtime::NodeKind::Rule => None,
    })
}

#[allow(dead_code)]
fn __token_children<'a>(
    source: __GeneratedRuleContext<'a>,
    token_type: i32,
) -> impl Iterator<Item = RuntimeTerminalNode<'a>> + 'a {
    __terminal_children(source)
        .filter(move |terminal| terminal.symbol().token_type() == token_type)
}

#[allow(dead_code)]
fn __token_children_matching<'a>(
    source: __GeneratedRuleContext<'a>,
    token_types: &'static [i32],
) -> impl Iterator<Item = RuntimeTerminalNode<'a>> + 'a {
    __terminal_children(source)
        .filter(move |terminal| token_types.contains(&terminal.symbol().token_type()))
}

#[allow(dead_code)]
fn __labeled_token_child(
    child: antlr4_runtime::Node<'_>,
) -> Option<RuntimeTerminalNode<'_>> {
    match child.kind() {
        antlr4_runtime::NodeKind::Terminal => child.as_terminal(),
        antlr4_runtime::NodeKind::Error => {
            let terminal = child
                .as_error()
                .map(antlr4_runtime::ErrorNodeView::terminal)?;
            terminal.symbol().is_synthetic().then_some(terminal)
        }
        antlr4_runtime::NodeKind::Rule => None,
    }
}

#[allow(dead_code)]
fn __labeled_token_children<'a>(
    source: __GeneratedRuleContext<'a>,
    token_type: i32,
) -> impl Iterator<Item = RuntimeTerminalNode<'a>> + 'a {
    __context_children(source).filter_map(move |child| {
        let terminal = __labeled_token_child(child)?;
        (terminal.symbol().token_type() == token_type).then_some(terminal)
    })
}

#[allow(dead_code)]
fn __labeled_token_children_matching<'a>(
    source: __GeneratedRuleContext<'a>,
    token_types: &'static [i32],
) -> impl Iterator<Item = RuntimeTerminalNode<'a>> + 'a {
    __context_children(source).filter_map(move |child| {
        let terminal = __labeled_token_child(child)?;
        token_types
            .contains(&terminal.symbol().token_type())
            .then_some(terminal)
    })
}

#[allow(dead_code)]
trait __FromActiveRuleContext<'a>: Sized {
    fn __from_active(
        context: &'a antlr4_runtime::ParserRuleContext,
        live_attrs: Option<&dyn std::any::Any>,
        invocation_states: Vec<isize>,
        storage: &'a antlr4_runtime::ParseTreeStorage,
        tokens: &'a antlr4_runtime::TokenStore,
    ) -> Option<Self>;
}

#[allow(dead_code)]
fn __active_context_view<'a, T: __FromActiveRuleContext<'a>>(
    context: &'a antlr4_runtime::ParserRuleContext,
    invocation_states: Vec<isize>,
    storage: &'a antlr4_runtime::ParseTreeStorage,
    tokens: &'a antlr4_runtime::TokenStore,
) -> Option<T> {
    T::__from_active(context, None, invocation_states, storage, tokens)
}

#[allow(dead_code)]
fn __active_context_view_with_attrs<'a, T: __FromActiveRuleContext<'a>>(
    context: &'a antlr4_runtime::ParserRuleContext,
    live_attrs: &dyn std::any::Any,
    invocation_states: Vec<isize>,
    storage: &'a antlr4_runtime::ParseTreeStorage,
    tokens: &'a antlr4_runtime::TokenStore,
) -> Option<T> {
    T::__from_active(
        context,
        Some(live_attrs),
        invocation_states,
        storage,
        tokens,
    )
}

#[allow(dead_code)]
fn __write_invocation_states(
    f: &mut std::fmt::Formatter<'_>,
    states: impl Iterator<Item = isize>,
) -> std::fmt::Result {
    f.write_str("[")?;
    let mut separator = "";
    for state in states {
        write!(f, "{separator}{state}")?;
        separator = " ";
    }
    f.write_str("]")
}

/// Marker carried by generated contexts whose required-child
/// invariants were checked after a syntax-clean parse.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ValidatedTreeContext {
    __private: (),
}

#[allow(dead_code)]
trait __RecoveryContextState {}

impl __RecoveryContextState for StoredTreeContext {}
impl __RecoveryContextState for __ActiveParserContext {}

/// A completed, syntax-clean parse tree whose generated child cardinalities
/// have been structurally validated.
#[derive(Debug)]
pub struct CSharpValidatedTree {
    parsed: antlr4_runtime::ParsedFile,
}

impl CSharpValidatedTree {
    fn __new(parsed: antlr4_runtime::ParsedFile) -> Self {
        Self { parsed }
    }

    /// Returns the validated entry-rule root.
    pub fn tree(&self) -> ValidatedRuleNode<'_> {
        let Some(rule) = self.parsed.tree().as_rule() else {
            unreachable!("validated parse root was checked as a rule node")
        };
        ValidatedRuleNode { __node: rule }
    }

    /// Borrows the underlying recovery-oriented parsed file.
    pub const fn parsed_file(&self) -> &antlr4_runtime::ParsedFile {
        &self.parsed
    }

    /// Drops the validation type boundary and returns the underlying parsed file.
    pub fn into_parsed_file(self) -> antlr4_runtime::ParsedFile {
        self.parsed
    }
}

/// A rule node borrowed from a [`CSharpValidatedTree`].
#[derive(Clone, Copy, Debug)]
pub struct ValidatedRuleNode<'a> {
    __node: RuleNodeView<'a>,
}

impl<'a> ValidatedRuleNode<'a> {
    pub const fn rule_node(self) -> RuleNodeView<'a> {
        self.__node
    }

    pub const fn node(self) -> antlr4_runtime::Node<'a> {
        self.__node.node()
    }

    pub fn rule_index(self) -> usize {
        self.__node.rule_index()
    }

    pub fn text(self) -> String {
        self.__node.text()
    }

    pub fn downcast_ref<T: FromValidatedRuleNode<'a>>(self) -> Option<T> {
        T::from_validated_rule_node(self)
    }
}

/// Constructs a generated validated context from a validated rule node.
pub trait FromValidatedRuleNode<'a>: Sized {
    fn from_validated_rule_node(node: ValidatedRuleNode<'a>) -> Option<Self>;
}

/// Failure to recognize or validate a strict generated parse.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CSharpValidationError {
    Recognition(antlr4_runtime::AntlrError),
    SyntaxErrors {
        lexer: usize,
        parser: usize,
    },
    MissingChild(MissingChildError),
    InvalidChildCount {
        context: &'static str,
        child: &'static str,
        minimum: usize,
        actual: usize,
    },
    RecoveredErrorNode {
        line: usize,
        column: usize,
        text: String,
    },
    InvalidRoot,
    UnknownRule {
        rule_index: usize,
    },
}

impl std::fmt::Display for CSharpValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Recognition(error) => write!(f, "parse failed: {error}"),
            Self::SyntaxErrors { lexer, parser } => write!(
                f,
                "parse produced {lexer} lexer and {parser} parser syntax errors"
            ),
            Self::MissingChild(error) => error.fmt(f),
            Self::InvalidChildCount {
                context,
                child,
                minimum,
                actual,
            } => write!(
                f,
                "required child {child} occurs {actual} times in {context}; expected at least {minimum}"
            ),
            Self::RecoveredErrorNode {
                line,
                column,
                text,
            } => write!(
                f,
                "recovered error node at {line}:{column}: {text}"
            ),
            Self::InvalidRoot => f.write_str("validated parse root is not a rule node"),
            Self::UnknownRule { rule_index } => write!(
                f,
                "parse tree contains unknown rule index {rule_index}"
            ),
        }
    }
}

impl std::error::Error for CSharpValidationError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::Recognition(error) => Some(error),
            Self::MissingChild(error) => Some(error),
            _ => None,
        }
    }
}

impl From<antlr4_runtime::AntlrError> for CSharpValidationError {
    fn from(error: antlr4_runtime::AntlrError) -> Self {
        Self::Recognition(error)
    }
}

impl From<MissingChildError> for CSharpValidationError {
    fn from(error: MissingChildError) -> Self {
        Self::MissingChild(error)
    }
}

#[allow(dead_code)]
fn __context_kind(context: RuleNodeView<'_>) -> usize {
    context.rule_index()
}

#[allow(dead_code)]
fn __active_context_kind(
    context: &antlr4_runtime::ParserRuleContext,
    _storage: &antlr4_runtime::ParseTreeStorage,
    _tokens: &antlr4_runtime::TokenStore,
) -> usize {
    context.rule_index()
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CompilationUnitContext {
        rule_index: 0,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CompilationUnitContext<'a, State> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn eof_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, -1)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CompilationUnitContext", "EOF"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CompilationUnitContext<'a, ValidatedTreeContext> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn eof_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, -1).next() else {
            unreachable!("validated CompilationUnitContext is missing required child EOF")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExternAliasDirectiveContext {
        rule_index: 1,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExternAliasDirectiveContext<'a, State> {
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExternAliasDirectiveContext", "identifier_token"))
    }
    pub fn kw_extern_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExternAliasDirectiveContext", "KW_EXTERN"))
    }
    pub fn kw_alias_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExternAliasDirectiveContext", "KW_ALIAS"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExternAliasDirectiveContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExternAliasDirectiveContext<'a, ValidatedTreeContext> {
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated ExternAliasDirectiveContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_extern_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 41).next() else {
            unreachable!("validated ExternAliasDirectiveContext is missing required child KW_EXTERN")
        };
        TerminalNode::new(node)
    }
    pub fn kw_alias_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 59).next() else {
            unreachable!("validated ExternAliasDirectiveContext is missing required child KW_ALIAS")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated ExternAliasDirectiveContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UsingDirectiveContext {
        rule_index: 2,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UsingDirectiveContext<'a, State> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UsingDirectiveContext", "type"))
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unsafe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UsingDirectiveContext", "KW_USING"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UsingDirectiveContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UsingDirectiveContext<'a, ValidatedTreeContext> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated UsingDirectiveContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unsafe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 77).next() else {
            unreachable!("validated UsingDirectiveContext is missing required child KW_USING")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated UsingDirectiveContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NameEqualsContext {
        rule_index: 3,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> NameEqualsContext<'a, State> {
    pub fn identifier_name(&self) -> Result<IdentifierNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("NameEqualsContext", "identifier_name"))
    }
    pub fn eq_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NameEqualsContext", "EQ"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NameEqualsContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> IdentifierNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 4).next() else {
            unreachable!("validated NameEqualsContext is missing required child identifier_name")
        };
        IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn eq_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 169).next() else {
            unreachable!("validated NameEqualsContext is missing required child EQ")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IdentifierNameContext {
        rule_index: 4,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> IdentifierNameContext<'a, State> {
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IdentifierNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AttributeListContext {
        rule_index: 5,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AttributeListContext<'a, State> {
    pub fn attribute_target_specifier(&self) -> Option<AttributeTargetSpecifierContext<'a>> {
        __rule_children(self.__node, 6)
            .next()
            .map(|node| AttributeTargetSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_children(&self) -> impl Iterator<Item = AttributeContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| AttributeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AttributeListContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AttributeListContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AttributeListContext<'a, ValidatedTreeContext> {
    pub fn attribute_target_specifier(&self) -> Option<AttributeTargetSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 6)
            .next()
            .map(|node| AttributeTargetSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_children(&self) -> impl Iterator<Item = AttributeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| AttributeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated AttributeListContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated AttributeListContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AttributeTargetSpecifierContext {
        rule_index: 6,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AttributeTargetSpecifierContext<'a, State> {
    pub fn syntax_token(&self) -> Result<SyntaxTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 220)
            .next()
            .map(|node| SyntaxTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AttributeTargetSpecifierContext", "syntax_token"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AttributeTargetSpecifierContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AttributeTargetSpecifierContext<'a, ValidatedTreeContext> {
    pub fn syntax_token(&self) -> SyntaxTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 220).next() else {
            unreachable!("validated AttributeTargetSpecifierContext is missing required child syntax_token")
        };
        SyntaxTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated AttributeTargetSpecifierContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AttributeContext {
        rule_index: 7,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AttributeContext<'a, State> {
    pub fn name(&self) -> Result<NameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AttributeContext", "name"))
    }
    pub fn attribute_argument_list(&self) -> Option<AttributeArgumentListContext<'a>> {
        __rule_children(self.__node, 13)
            .next()
            .map(|node| AttributeArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AttributeContext<'a, ValidatedTreeContext> {
    pub fn name(&self) -> NameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 8).next() else {
            unreachable!("validated AttributeContext is missing required child name")
        };
        NameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn attribute_argument_list(&self) -> Option<AttributeArgumentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 13)
            .next()
            .map(|node| AttributeArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NameContext {
        rule_index: 8,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> NameContext<'a, State> {
    pub fn name(&self) -> Option<NameContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn alias_qualified_name(&self) -> Option<AliasQualifiedNameContext<'a>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| AliasQualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_name(&self) -> Option<SimpleNameContext<'a>> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NameContext<'a, ValidatedTreeContext> {
    pub fn name(&self) -> Option<NameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn alias_qualified_name(&self) -> Option<AliasQualifiedNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| AliasQualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_name(&self) -> Option<SimpleNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AliasQualifiedNameContext {
        rule_index: 9,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AliasQualifiedNameContext<'a, State> {
    pub fn identifier_name(&self) -> Result<IdentifierNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AliasQualifiedNameContext", "identifier_name"))
    }
    pub fn simple_name(&self) -> Result<SimpleNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AliasQualifiedNameContext", "simple_name"))
    }
    pub fn colon_colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 133)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AliasQualifiedNameContext", "COLON_COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AliasQualifiedNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> IdentifierNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 4).next() else {
            unreachable!("validated AliasQualifiedNameContext is missing required child identifier_name")
        };
        IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn simple_name(&self) -> SimpleNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 10).next() else {
            unreachable!("validated AliasQualifiedNameContext is missing required child simple_name")
        };
        SimpleNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 133).next() else {
            unreachable!("validated AliasQualifiedNameContext is missing required child COLON_COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SimpleNameContext {
        rule_index: 10,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SimpleNameContext<'a, State> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_name(&self) -> Option<GenericNameContext<'a>> {
        __rule_children(self.__node, 11)
            .next()
            .map(|node| GenericNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SimpleNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_name(&self) -> Option<GenericNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 11)
            .next()
            .map(|node| GenericNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GenericNameContext {
        rule_index: 11,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> GenericNameContext<'a, State> {
    pub fn type_argument_list(&self) -> Result<TypeArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| TypeArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericNameContext", "type_argument_list"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericNameContext", "identifier_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GenericNameContext<'a, ValidatedTreeContext> {
    pub fn type_argument_list(&self) -> TypeArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 12).next() else {
            unreachable!("validated GenericNameContext is missing required child type_argument_list")
        };
        TypeArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated GenericNameContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeArgumentListContext {
        rule_index: 12,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeArgumentListContext<'a, State> {
    pub fn type_children(&self) -> impl Iterator<Item = TypeContext<'a>> + '_ {
        __rule_children(self.__node, 76)
            .map(move |node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeArgumentListContext", "LT"))
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeArgumentListContext", "GT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeArgumentListContext<'a, ValidatedTreeContext> {
    pub fn type_children(&self) -> impl Iterator<Item = TypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 76)
            .map(move |node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 168).next() else {
            unreachable!("validated TypeArgumentListContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 170).next() else {
            unreachable!("validated TypeArgumentListContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AttributeArgumentListContext {
        rule_index: 13,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AttributeArgumentListContext<'a, State> {
    pub fn attribute_argument_children(&self) -> impl Iterator<Item = AttributeArgumentContext<'a>> + '_ {
        __rule_children(self.__node, 14)
            .map(move |node| AttributeArgumentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AttributeArgumentListContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AttributeArgumentListContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AttributeArgumentListContext<'a, ValidatedTreeContext> {
    pub fn attribute_argument_children(&self) -> impl Iterator<Item = AttributeArgumentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 14)
            .map(move |node| AttributeArgumentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated AttributeArgumentListContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated AttributeArgumentListContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AttributeArgumentContext {
        rule_index: 14,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AttributeArgumentContext<'a, State> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name_colon(&self) -> Option<NameColonContext<'a>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AttributeArgumentContext", "expression"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AttributeArgumentContext<'a, ValidatedTreeContext> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name_colon(&self) -> Option<NameColonContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated AttributeArgumentContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NameColonContext {
        rule_index: 15,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> NameColonContext<'a, State> {
    pub fn identifier_name(&self) -> Result<IdentifierNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("NameColonContext", "identifier_name"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NameColonContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NameColonContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> IdentifierNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 4).next() else {
            unreachable!("validated NameColonContext is missing required child identifier_name")
        };
        IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated NameColonContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MemberDeclarationContext {
        rule_index: 16,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> MemberDeclarationContext<'a, State> {
    pub fn base_field_declaration(&self) -> Option<BaseFieldDeclarationContext<'a>> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| BaseFieldDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_method_declaration(&self) -> Option<BaseMethodDeclarationContext<'a>> {
        __rule_children(self.__node, 26)
            .next()
            .map(|node| BaseMethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_namespace_declaration(&self) -> Option<BaseNamespaceDeclarationContext<'a>> {
        __rule_children(self.__node, 50)
            .next()
            .map(|node| BaseNamespaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_property_declaration(&self) -> Option<BasePropertyDeclarationContext<'a>> {
        __rule_children(self.__node, 53)
            .next()
            .map(|node| BasePropertyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_type_declaration(&self) -> Option<BaseTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 60)
            .next()
            .map(|node| BaseTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_member_declaration(&self) -> Option<EnumMemberDeclarationContext<'a>> {
        __rule_children(self.__node, 66)
            .next()
            .map(|node| EnumMemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extension_block_declaration(&self) -> Option<ExtensionBlockDeclarationContext<'a>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| ExtensionBlockDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 71)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn union_declaration(&self) -> Option<UnionDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| UnionDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn delegate_declaration(&self) -> Option<DelegateDeclarationContext<'a>> {
        __rule_children(self.__node, 74)
            .next()
            .map(|node| DelegateDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn global_statement(&self) -> Option<GlobalStatementContext<'a>> {
        __rule_children(self.__node, 75)
            .next()
            .map(|node| GlobalStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MemberDeclarationContext<'a, ValidatedTreeContext> {
    pub fn base_field_declaration(&self) -> Option<BaseFieldDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| BaseFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_method_declaration(&self) -> Option<BaseMethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 26)
            .next()
            .map(|node| BaseMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_namespace_declaration(&self) -> Option<BaseNamespaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 50)
            .next()
            .map(|node| BaseNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_property_declaration(&self) -> Option<BasePropertyDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 53)
            .next()
            .map(|node| BasePropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_type_declaration(&self) -> Option<BaseTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 60)
            .next()
            .map(|node| BaseTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_member_declaration(&self) -> Option<EnumMemberDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 66)
            .next()
            .map(|node| EnumMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extension_block_declaration(&self) -> Option<ExtensionBlockDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| ExtensionBlockDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 71)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn union_declaration(&self) -> Option<UnionDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| UnionDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn delegate_declaration(&self) -> Option<DelegateDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 74)
            .next()
            .map(|node| DelegateDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn global_statement(&self) -> Option<GlobalStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 75)
            .next()
            .map(|node| GlobalStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseFieldDeclarationContext {
        rule_index: 17,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseFieldDeclarationContext<'a, State> {
    pub fn event_field_declaration(&self) -> Option<EventFieldDeclarationContext<'a>> {
        __rule_children(self.__node, 18)
            .next()
            .map(|node| EventFieldDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_declaration(&self) -> Option<FieldDeclarationContext<'a>> {
        __rule_children(self.__node, 25)
            .next()
            .map(|node| FieldDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseFieldDeclarationContext<'a, ValidatedTreeContext> {
    pub fn event_field_declaration(&self) -> Option<EventFieldDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 18)
            .next()
            .map(|node| EventFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_declaration(&self) -> Option<FieldDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 25)
            .next()
            .map(|node| FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EventFieldDeclarationContext {
        rule_index: 18,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EventFieldDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Result<VariableDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EventFieldDeclarationContext", "variable_declaration"))
    }
    pub fn kw_event_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EventFieldDeclarationContext", "KW_EVENT"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EventFieldDeclarationContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EventFieldDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> VariableDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 20).next() else {
            unreachable!("validated EventFieldDeclarationContext is missing required child variable_declaration")
        };
        VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_event_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 66).next() else {
            unreachable!("validated EventFieldDeclarationContext is missing required child KW_EVENT")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated EventFieldDeclarationContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ModifierContext {
        rule_index: 19,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ModifierContext<'a, State> {
    pub fn kw_protected_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 13)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 16)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_internal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 21)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_override_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 23)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_readonly_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_volatile_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 26)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_private_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_virtual_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extern_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 45)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unsafe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_const_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 65)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_fixed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 69)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ModifierContext<'a, ValidatedTreeContext> {
    pub fn kw_protected_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 13)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 16)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_internal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 21)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_override_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 23)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_readonly_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_volatile_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 26)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_private_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_virtual_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extern_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 45)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unsafe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_const_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 65)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_fixed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 69)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDeclarationContext {
        rule_index: 20,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> VariableDeclarationContext<'a, State> {
    pub fn variable_declarator_children(&self) -> impl Iterator<Item = VariableDeclaratorContext<'a>> + '_ {
        __rule_children(self.__node, 21)
            .map(move |node| VariableDeclaratorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("VariableDeclarationContext", "type"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDeclarationContext<'a, ValidatedTreeContext> {
    pub fn variable_declarator_children(&self) -> impl Iterator<Item = VariableDeclaratorContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 21)
            .map(move |node| VariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated VariableDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDeclaratorContext {
        rule_index: 21,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> VariableDeclaratorContext<'a, State> {
    pub fn bracketed_argument_list(&self) -> Option<BracketedArgumentListContext<'a>> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("VariableDeclaratorContext", "identifier_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDeclaratorContext<'a, ValidatedTreeContext> {
    pub fn bracketed_argument_list(&self) -> Option<BracketedArgumentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated VariableDeclaratorContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BracketedArgumentListContext {
        rule_index: 22,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BracketedArgumentListContext<'a, State> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BracketedArgumentListContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BracketedArgumentListContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BracketedArgumentListContext<'a, ValidatedTreeContext> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated BracketedArgumentListContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated BracketedArgumentListContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArgumentContext {
        rule_index: 23,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArgumentContext<'a, State> {
    pub fn name_colon(&self) -> Option<NameColonContext<'a>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ArgumentContext", "expression"))
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArgumentContext<'a, ValidatedTreeContext> {
    pub fn name_colon(&self) -> Option<NameColonContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ArgumentContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EqualsValueClauseContext {
        rule_index: 24,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EqualsValueClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EqualsValueClauseContext", "expression"))
    }
    pub fn eq_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EqualsValueClauseContext", "EQ"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EqualsValueClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated EqualsValueClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn eq_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 169).next() else {
            unreachable!("validated EqualsValueClauseContext is missing required child EQ")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FieldDeclarationContext {
        rule_index: 25,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FieldDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Result<VariableDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FieldDeclarationContext", "variable_declaration"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FieldDeclarationContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FieldDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> VariableDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 20).next() else {
            unreachable!("validated FieldDeclarationContext is missing required child variable_declaration")
        };
        VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated FieldDeclarationContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseMethodDeclarationContext {
        rule_index: 26,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseMethodDeclarationContext<'a, State> {
    pub fn constructor_declaration(&self) -> Option<ConstructorDeclarationContext<'a>> {
        __rule_children(self.__node, 27)
            .next()
            .map(|node| ConstructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn conversion_operator_declaration(&self) -> Option<ConversionOperatorDeclarationContext<'a>> {
        __rule_children(self.__node, 34)
            .next()
            .map(|node| ConversionOperatorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn destructor_declaration(&self) -> Option<DestructorDeclarationContext<'a>> {
        __rule_children(self.__node, 36)
            .next()
            .map(|node| DestructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_declaration(&self) -> Option<MethodDeclarationContext<'a>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| MethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn operator_declaration(&self) -> Option<OperatorDeclarationContext<'a>> {
        __rule_children(self.__node, 49)
            .next()
            .map(|node| OperatorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseMethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn constructor_declaration(&self) -> Option<ConstructorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 27)
            .next()
            .map(|node| ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn conversion_operator_declaration(&self) -> Option<ConversionOperatorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 34)
            .next()
            .map(|node| ConversionOperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn destructor_declaration(&self) -> Option<DestructorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 36)
            .next()
            .map(|node| DestructorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_declaration(&self) -> Option<MethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn operator_declaration(&self) -> Option<OperatorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 49)
            .next()
            .map(|node| OperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstructorDeclarationContext {
        rule_index: 27,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ConstructorDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "parameter_list"))
    }
    pub fn constructor_initializer(&self) -> Option<ConstructorInitializerContext<'a>> {
        __rule_children(self.__node, 30)
            .next()
            .map(|node| ConstructorInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "identifier_token"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstructorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated ConstructorDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn constructor_initializer(&self) -> Option<ConstructorInitializerContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 30)
            .next()
            .map(|node| ConstructorInitializerContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated ConstructorDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParameterListContext {
        rule_index: 28,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParameterListContext<'a, State> {
    pub fn parameter_children(&self) -> impl Iterator<Item = ParameterContext<'a>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| ParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParameterListContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParameterListContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParameterListContext<'a, ValidatedTreeContext> {
    pub fn parameter_children(&self) -> impl Iterator<Item = ParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| ParameterContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ParameterListContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ParameterListContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParameterContext {
        rule_index: 29,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParameterContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_params_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 44).map(TerminalNode::new)
    }
    pub fn kw_this_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 98).map(TerminalNode::new)
    }
    pub fn kw_out_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 115).map(TerminalNode::new)
    }
    pub fn kw_in_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 149).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParameterContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_params_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 44).map(TerminalNode::new)
    }
    pub fn kw_this_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 98).map(TerminalNode::new)
    }
    pub fn kw_out_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 115).map(TerminalNode::new)
    }
    pub fn kw_in_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 149).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstructorInitializerContext {
        rule_index: 30,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ConstructorInitializerContext<'a, State> {
    pub fn argument_list(&self) -> Result<ArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorInitializerContext", "argument_list"))
    }
    pub fn kw_base_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstructorInitializerContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstructorInitializerContext<'a, ValidatedTreeContext> {
    pub fn argument_list(&self) -> ArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 31).next() else {
            unreachable!("validated ConstructorInitializerContext is missing required child argument_list")
        };
        ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_base_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated ConstructorInitializerContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArgumentListContext {
        rule_index: 31,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArgumentListContext<'a, State> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArgumentListContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArgumentListContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArgumentListContext<'a, ValidatedTreeContext> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ArgumentListContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ArgumentListContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BlockContext {
        rule_index: 32,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BlockContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement_children(&self) -> impl Iterator<Item = StatementContext<'a>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BlockContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BlockContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BlockContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement_children(&self) -> impl Iterator<Item = StatementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| StatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated BlockContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated BlockContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrowExpressionClauseContext {
        rule_index: 33,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArrowExpressionClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ArrowExpressionClauseContext", "expression"))
    }
    pub fn arrow_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrowExpressionClauseContext", "ARROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrowExpressionClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ArrowExpressionClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn arrow_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 138).next() else {
            unreachable!("validated ArrowExpressionClauseContext is missing required child ARROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConversionOperatorDeclarationContext {
        rule_index: 34,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ConversionOperatorDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConversionOperatorDeclarationContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConversionOperatorDeclarationContext", "type"))
    }
    pub fn kw_explicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_implicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 20)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_operator_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConversionOperatorDeclarationContext", "KW_OPERATOR"))
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConversionOperatorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated ConversionOperatorDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated ConversionOperatorDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_explicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_implicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 20)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_operator_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 22).next() else {
            unreachable!("validated ConversionOperatorDeclarationContext is missing required child KW_OPERATOR")
        };
        TerminalNode::new(node)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExplicitInterfaceSpecifierContext {
        rule_index: 35,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExplicitInterfaceSpecifierContext<'a, State> {
    pub fn name(&self) -> Result<NameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExplicitInterfaceSpecifierContext", "name"))
    }
    pub fn dot_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExplicitInterfaceSpecifierContext", "DOT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext> {
    pub fn name(&self) -> NameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 8).next() else {
            unreachable!("validated ExplicitInterfaceSpecifierContext is missing required child name")
        };
        NameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn dot_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 165).next() else {
            unreachable!("validated ExplicitInterfaceSpecifierContext is missing required child DOT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DestructorDeclarationContext {
        rule_index: 36,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DestructorDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DestructorDeclarationContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DestructorDeclarationContext", "identifier_token"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DestructorDeclarationContext", "TILDE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DestructorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated DestructorDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated DestructorDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 175).next() else {
            unreachable!("validated DestructorDeclarationContext is missing required child TILDE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodDeclarationContext {
        rule_index: 37,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> MethodDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "type"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "identifier_token"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParameterListContext {
        rule_index: 38,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeParameterListContext<'a, State> {
    pub fn type_parameter_children(&self) -> impl Iterator<Item = TypeParameterContext<'a>> + '_ {
        __rule_children(self.__node, 39)
            .map(move |node| TypeParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParameterListContext", "LT"))
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParameterListContext", "GT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParameterListContext<'a, ValidatedTreeContext> {
    pub fn type_parameter_children(&self) -> impl Iterator<Item = TypeParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 39)
            .map(move |node| TypeParameterContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 168).next() else {
            unreachable!("validated TypeParameterListContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 170).next() else {
            unreachable!("validated TypeParameterListContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParameterContext {
        rule_index: 39,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeParameterContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypeParameterContext", "identifier_token"))
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParameterContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated TypeParameterContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParameterConstraintClauseContext {
        rule_index: 40,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeParameterConstraintClauseContext<'a, State> {
    pub fn identifier_name(&self) -> Result<IdentifierNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypeParameterConstraintClauseContext", "identifier_name"))
    }
    pub fn type_parameter_constraint_children(&self) -> impl Iterator<Item = TypeParameterConstraintContext<'a>> + '_ {
        __rule_children(self.__node, 41)
            .map(move |node| TypeParameterConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_where_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParameterConstraintClauseContext", "KW_WHERE"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParameterConstraintClauseContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParameterConstraintClauseContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> IdentifierNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 4).next() else {
            unreachable!("validated TypeParameterConstraintClauseContext is missing required child identifier_name")
        };
        IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_parameter_constraint_children(&self) -> impl Iterator<Item = TypeParameterConstraintContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 41)
            .map(move |node| TypeParameterConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_where_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 78).next() else {
            unreachable!("validated TypeParameterConstraintClauseContext is missing required child KW_WHERE")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated TypeParameterConstraintClauseContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParameterConstraintContext {
        rule_index: 41,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeParameterConstraintContext<'a, State> {
    pub fn allows_constraint_clause(&self) -> Option<AllowsConstraintClauseContext<'a>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| AllowsConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_struct_constraint(&self) -> Option<ClassOrStructConstraintContext<'a>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| ClassOrStructConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constructor_constraint(&self) -> Option<ConstructorConstraintContext<'a>> {
        __rule_children(self.__node, 46)
            .next()
            .map(|node| ConstructorConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_constraint(&self) -> Option<DefaultConstraintContext<'a>> {
        __rule_children(self.__node, 47)
            .next()
            .map(|node| DefaultConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_constraint(&self) -> Option<TypeConstraintContext<'a>> {
        __rule_children(self.__node, 48)
            .next()
            .map(|node| TypeConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParameterConstraintContext<'a, ValidatedTreeContext> {
    pub fn allows_constraint_clause(&self) -> Option<AllowsConstraintClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| AllowsConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_struct_constraint(&self) -> Option<ClassOrStructConstraintContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| ClassOrStructConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constructor_constraint(&self) -> Option<ConstructorConstraintContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 46)
            .next()
            .map(|node| ConstructorConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_constraint(&self) -> Option<DefaultConstraintContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 47)
            .next()
            .map(|node| DefaultConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_constraint(&self) -> Option<TypeConstraintContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 48)
            .next()
            .map(|node| TypeConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AllowsConstraintClauseContext {
        rule_index: 42,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AllowsConstraintClauseContext<'a, State> {
    pub fn allows_constraint_children(&self) -> impl Iterator<Item = AllowsConstraintContext<'a>> + '_ {
        __rule_children(self.__node, 43)
            .map(move |node| AllowsConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_allows_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AllowsConstraintClauseContext", "KW_ALLOWS"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AllowsConstraintClauseContext<'a, ValidatedTreeContext> {
    pub fn allows_constraint_children(&self) -> impl Iterator<Item = AllowsConstraintContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 43)
            .map(move |node| AllowsConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_allows_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 37).next() else {
            unreachable!("validated AllowsConstraintClauseContext is missing required child KW_ALLOWS")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AllowsConstraintContext {
        rule_index: 43,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AllowsConstraintContext<'a, State> {
    pub fn ref_struct_constraint(&self) -> Result<RefStructConstraintContext<'a>, MissingChildError> {
        __rule_children(self.__node, 44)
            .next()
            .map(|node| RefStructConstraintContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AllowsConstraintContext", "ref_struct_constraint"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AllowsConstraintContext<'a, ValidatedTreeContext> {
    pub fn ref_struct_constraint(&self) -> RefStructConstraintContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 44).next() else {
            unreachable!("validated AllowsConstraintContext is missing required child ref_struct_constraint")
        };
        RefStructConstraintContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RefStructConstraintContext {
        rule_index: 44,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RefStructConstraintContext<'a, State> {
    pub fn kw_struct_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefStructConstraintContext", "KW_STRUCT"))
    }
    pub fn kw_ref_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefStructConstraintContext", "KW_REF"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RefStructConstraintContext<'a, ValidatedTreeContext> {
    pub fn kw_struct_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 54).next() else {
            unreachable!("validated RefStructConstraintContext is missing required child KW_STRUCT")
        };
        TerminalNode::new(node)
    }
    pub fn kw_ref_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 116).next() else {
            unreachable!("validated RefStructConstraintContext is missing required child KW_REF")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassOrStructConstraintContext {
        rule_index: 45,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ClassOrStructConstraintContext<'a, State> {
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassOrStructConstraintContext<'a, ValidatedTreeContext> {
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstructorConstraintContext {
        rule_index: 46,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ConstructorConstraintContext<'a, State> {
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstructorConstraintContext", "KW_NEW"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstructorConstraintContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstructorConstraintContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstructorConstraintContext<'a, ValidatedTreeContext> {
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated ConstructorConstraintContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ConstructorConstraintContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ConstructorConstraintContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DefaultConstraintContext {
        rule_index: 47,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DefaultConstraintContext<'a, State> {
    pub fn kw_default_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultConstraintContext", "KW_DEFAULT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DefaultConstraintContext<'a, ValidatedTreeContext> {
    pub fn kw_default_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 29).next() else {
            unreachable!("validated DefaultConstraintContext is missing required child KW_DEFAULT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeConstraintContext {
        rule_index: 48,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeConstraintContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypeConstraintContext", "type"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeConstraintContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated TypeConstraintContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct OperatorDeclarationContext {
        rule_index: 49,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> OperatorDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("OperatorDeclarationContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("OperatorDeclarationContext", "type"))
    }
    pub fn right_shift(&self) -> Option<RightShiftContext<'a>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_operator_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("OperatorDeclarationContext", "KW_OPERATOR"))
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> OperatorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated OperatorDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated OperatorDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn right_shift(&self) -> Option<RightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_operator_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 22).next() else {
            unreachable!("validated OperatorDeclarationContext is missing required child KW_OPERATOR")
        };
        TerminalNode::new(node)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseNamespaceDeclarationContext {
        rule_index: 50,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseNamespaceDeclarationContext<'a, State> {
    pub fn file_scoped_namespace_declaration(&self) -> Option<FileScopedNamespaceDeclarationContext<'a>> {
        __rule_children(self.__node, 51)
            .next()
            .map(|node| FileScopedNamespaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn namespace_declaration(&self) -> Option<NamespaceDeclarationContext<'a>> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| NamespaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseNamespaceDeclarationContext<'a, ValidatedTreeContext> {
    pub fn file_scoped_namespace_declaration(&self) -> Option<FileScopedNamespaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 51)
            .next()
            .map(|node| FileScopedNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn namespace_declaration(&self) -> Option<NamespaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| NamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FileScopedNamespaceDeclarationContext {
        rule_index: 51,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FileScopedNamespaceDeclarationContext<'a, State> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name(&self) -> Result<NameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FileScopedNamespaceDeclarationContext", "name"))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_namespace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FileScopedNamespaceDeclarationContext", "KW_NAMESPACE"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FileScopedNamespaceDeclarationContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FileScopedNamespaceDeclarationContext<'a, ValidatedTreeContext> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name(&self) -> NameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 8).next() else {
            unreachable!("validated FileScopedNamespaceDeclarationContext is missing required child name")
        };
        NameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_namespace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 12).next() else {
            unreachable!("validated FileScopedNamespaceDeclarationContext is missing required child KW_NAMESPACE")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated FileScopedNamespaceDeclarationContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NamespaceDeclarationContext {
        rule_index: 52,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> NamespaceDeclarationContext<'a, State> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name(&self) -> Result<NameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("NamespaceDeclarationContext", "name"))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_namespace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NamespaceDeclarationContext", "KW_NAMESPACE"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NamespaceDeclarationContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NamespaceDeclarationContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NamespaceDeclarationContext<'a, ValidatedTreeContext> {
    pub fn extern_alias_directive_children(&self) -> impl Iterator<Item = ExternAliasDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 1)
            .map(move |node| ExternAliasDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_directive_children(&self) -> impl Iterator<Item = UsingDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 2)
            .map(move |node| UsingDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn name(&self) -> NameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 8).next() else {
            unreachable!("validated NamespaceDeclarationContext is missing required child name")
        };
        NameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_namespace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 12).next() else {
            unreachable!("validated NamespaceDeclarationContext is missing required child KW_NAMESPACE")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated NamespaceDeclarationContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated NamespaceDeclarationContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BasePropertyDeclarationContext {
        rule_index: 53,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BasePropertyDeclarationContext<'a, State> {
    pub fn event_declaration(&self) -> Option<EventDeclarationContext<'a>> {
        __rule_children(self.__node, 54)
            .next()
            .map(|node| EventDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn indexer_declaration(&self) -> Option<IndexerDeclarationContext<'a>> {
        __rule_children(self.__node, 57)
            .next()
            .map(|node| IndexerDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn property_declaration(&self) -> Option<PropertyDeclarationContext<'a>> {
        __rule_children(self.__node, 59)
            .next()
            .map(|node| PropertyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BasePropertyDeclarationContext<'a, ValidatedTreeContext> {
    pub fn event_declaration(&self) -> Option<EventDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 54)
            .next()
            .map(|node| EventDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn indexer_declaration(&self) -> Option<IndexerDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 57)
            .next()
            .map(|node| IndexerDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn property_declaration(&self) -> Option<PropertyDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 59)
            .next()
            .map(|node| PropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EventDeclarationContext {
        rule_index: 54,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EventDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EventDeclarationContext", "type"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EventDeclarationContext", "identifier_token"))
    }
    pub fn kw_event_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EventDeclarationContext", "KW_EVENT"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EventDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated EventDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated EventDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_event_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 66).next() else {
            unreachable!("validated EventDeclarationContext is missing required child KW_EVENT")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AccessorListContext {
        rule_index: 55,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AccessorListContext<'a, State> {
    pub fn accessor_declaration_children(&self) -> impl Iterator<Item = AccessorDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AccessorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AccessorListContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AccessorListContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AccessorListContext<'a, ValidatedTreeContext> {
    pub fn accessor_declaration_children(&self) -> impl Iterator<Item = AccessorDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AccessorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated AccessorListContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated AccessorListContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AccessorDeclarationContext {
        rule_index: 56,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AccessorDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AccessorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IndexerDeclarationContext {
        rule_index: 57,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> IndexerDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bracketed_parameter_list(&self) -> Result<BracketedParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 58)
            .next()
            .map(|node| BracketedParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("IndexerDeclarationContext", "bracketed_parameter_list"))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("IndexerDeclarationContext", "type"))
    }
    pub fn kw_this_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("IndexerDeclarationContext", "KW_THIS"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IndexerDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bracketed_parameter_list(&self) -> BracketedParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 58).next() else {
            unreachable!("validated IndexerDeclarationContext is missing required child bracketed_parameter_list")
        };
        BracketedParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated IndexerDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_this_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 98).next() else {
            unreachable!("validated IndexerDeclarationContext is missing required child KW_THIS")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BracketedParameterListContext {
        rule_index: 58,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BracketedParameterListContext<'a, State> {
    pub fn parameter_children(&self) -> impl Iterator<Item = ParameterContext<'a>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| ParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BracketedParameterListContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BracketedParameterListContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BracketedParameterListContext<'a, ValidatedTreeContext> {
    pub fn parameter_children(&self) -> impl Iterator<Item = ParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| ParameterContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated BracketedParameterListContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated BracketedParameterListContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PropertyDeclarationContext {
        rule_index: 59,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PropertyDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PropertyDeclarationContext", "type"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PropertyDeclarationContext", "identifier_token"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PropertyDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_interface_specifier(&self) -> Option<ExplicitInterfaceSpecifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn accessor_list(&self) -> Option<AccessorListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| AccessorListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated PropertyDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated PropertyDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseTypeDeclarationContext {
        rule_index: 60,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseTypeDeclarationContext<'a, State> {
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 61)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_declaration(&self) -> Option<TypeDeclarationContext<'a>> {
        __rule_children(self.__node, 67)
            .next()
            .map(|node| TypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseTypeDeclarationContext<'a, ValidatedTreeContext> {
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 61)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_declaration(&self) -> Option<TypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 67)
            .next()
            .map(|node| TypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumDeclarationContext {
        rule_index: 61,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EnumDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_member_declaration_children(&self) -> impl Iterator<Item = EnumMemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 66)
            .map(move |node| EnumMemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "identifier_token"))
    }
    pub fn kw_enum_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "KW_ENUM"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_member_declaration_children(&self) -> impl Iterator<Item = EnumMemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 66)
            .map(move |node| EnumMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_enum_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 87).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child KW_ENUM")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseListContext {
        rule_index: 62,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseListContext<'a, State> {
    pub fn base_type_children(&self) -> impl Iterator<Item = BaseTypeContext<'a>> + '_ {
        __rule_children(self.__node, 63)
            .map(move |node| BaseTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BaseListContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseListContext<'a, ValidatedTreeContext> {
    pub fn base_type_children(&self) -> impl Iterator<Item = BaseTypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 63)
            .map(move |node| BaseTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated BaseListContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseTypeContext {
        rule_index: 63,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseTypeContext<'a, State> {
    pub fn primary_constructor_base_type(&self) -> Option<PrimaryConstructorBaseTypeContext<'a>> {
        __rule_children(self.__node, 64)
            .next()
            .map(|node| PrimaryConstructorBaseTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_base_type(&self) -> Option<SimpleBaseTypeContext<'a>> {
        __rule_children(self.__node, 65)
            .next()
            .map(|node| SimpleBaseTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseTypeContext<'a, ValidatedTreeContext> {
    pub fn primary_constructor_base_type(&self) -> Option<PrimaryConstructorBaseTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 64)
            .next()
            .map(|node| PrimaryConstructorBaseTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_base_type(&self) -> Option<SimpleBaseTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 65)
            .next()
            .map(|node| SimpleBaseTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PrimaryConstructorBaseTypeContext {
        rule_index: 64,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PrimaryConstructorBaseTypeContext<'a, State> {
    pub fn argument_list(&self) -> Result<ArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PrimaryConstructorBaseTypeContext", "argument_list"))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PrimaryConstructorBaseTypeContext", "type"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PrimaryConstructorBaseTypeContext<'a, ValidatedTreeContext> {
    pub fn argument_list(&self) -> ArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 31).next() else {
            unreachable!("validated PrimaryConstructorBaseTypeContext is missing required child argument_list")
        };
        ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated PrimaryConstructorBaseTypeContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SimpleBaseTypeContext {
        rule_index: 65,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SimpleBaseTypeContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SimpleBaseTypeContext", "type"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SimpleBaseTypeContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated SimpleBaseTypeContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumMemberDeclarationContext {
        rule_index: 66,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EnumMemberDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnumMemberDeclarationContext", "identifier_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumMemberDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated EnumMemberDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeDeclarationContext {
        rule_index: 67,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeDeclarationContext<'a, State> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 68)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extension_block_declaration(&self) -> Option<ExtensionBlockDeclarationContext<'a>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| ExtensionBlockDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 70)
            .next()
            .map(|node| InterfaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 71)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn struct_declaration(&self) -> Option<StructDeclarationContext<'a>> {
        __rule_children(self.__node, 72)
            .next()
            .map(|node| StructDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn union_declaration(&self) -> Option<UnionDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| UnionDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeDeclarationContext<'a, ValidatedTreeContext> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 68)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extension_block_declaration(&self) -> Option<ExtensionBlockDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| ExtensionBlockDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 70)
            .next()
            .map(|node| InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 71)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn struct_declaration(&self) -> Option<StructDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 72)
            .next()
            .map(|node| StructDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn union_declaration(&self) -> Option<UnionDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| UnionDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassDeclarationContext {
        rule_index: 68,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ClassDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ClassDeclarationContext", "identifier_token"))
    }
    pub fn kw_class_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ClassDeclarationContext", "KW_CLASS"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated ClassDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_class_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 64).next() else {
            unreachable!("validated ClassDeclarationContext is missing required child KW_CLASS")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExtensionBlockDeclarationContext {
        rule_index: 69,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExtensionBlockDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_extension_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 10)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExtensionBlockDeclarationContext", "KW_EXTENSION"))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExtensionBlockDeclarationContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExtensionBlockDeclarationContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExtensionBlockDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_extension_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 10).next() else {
            unreachable!("validated ExtensionBlockDeclarationContext is missing required child KW_EXTENSION")
        };
        TerminalNode::new(node)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated ExtensionBlockDeclarationContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated ExtensionBlockDeclarationContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceDeclarationContext {
        rule_index: 70,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterfaceDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceDeclarationContext", "identifier_token"))
    }
    pub fn kw_interface_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 11)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterfaceDeclarationContext", "KW_INTERFACE"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated InterfaceDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_interface_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 11).next() else {
            unreachable!("validated InterfaceDeclarationContext is missing required child KW_INTERFACE")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordDeclarationContext {
        rule_index: 71,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RecordDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "identifier_token"))
    }
    pub fn record_keyword(&self) -> Result<RecordKeywordContext<'a>, MissingChildError> {
        __rule_children(self.__node, 237)
            .next()
            .map(|node| RecordKeywordContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "record_keyword"))
    }
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn record_keyword(&self) -> RecordKeywordContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 237).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child record_keyword")
        };
        RecordKeywordContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct StructDeclarationContext {
        rule_index: 72,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> StructDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("StructDeclarationContext", "identifier_token"))
    }
    pub fn kw_struct_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("StructDeclarationContext", "KW_STRUCT"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> StructDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated StructDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_struct_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 54).next() else {
            unreachable!("validated StructDeclarationContext is missing required child KW_STRUCT")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnionDeclarationContext {
        rule_index: 73,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnionDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UnionDeclarationContext", "identifier_token"))
    }
    pub fn kw_union_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnionDeclarationContext", "KW_UNION"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnionDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration_children(&self) -> impl Iterator<Item = MemberDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 16)
            .map(move |node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_list(&self) -> Option<BaseListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| BaseListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated UnionDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_union_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 76).next() else {
            unreachable!("validated UnionDeclarationContext is missing required child KW_UNION")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DelegateDeclarationContext {
        rule_index: 74,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DelegateDeclarationContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DelegateDeclarationContext", "parameter_list"))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DelegateDeclarationContext", "type"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DelegateDeclarationContext", "identifier_token"))
    }
    pub fn kw_delegate_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DelegateDeclarationContext", "KW_DELEGATE"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DelegateDeclarationContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DelegateDeclarationContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated DelegateDeclarationContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated DelegateDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated DelegateDeclarationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_delegate_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 18).next() else {
            unreachable!("validated DelegateDeclarationContext is missing required child KW_DELEGATE")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated DelegateDeclarationContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GlobalStatementContext {
        rule_index: 75,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> GlobalStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GlobalStatementContext", "statement"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GlobalStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated GlobalStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeContext {
        rule_index: 76,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeContext<'a, State> {
    pub fn name(&self) -> Option<NameContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn array_rank_specifier_children(&self) -> impl Iterator<Item = ArrayRankSpecifierContext<'a>> + '_ {
        __rule_children(self.__node, 78)
            .map(move |node| ArrayRankSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn function_pointer_type(&self) -> Option<FunctionPointerTypeContext<'a>> {
        __rule_children(self.__node, 79)
            .next()
            .map(|node| FunctionPointerTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn predefined_type(&self) -> Option<PredefinedTypeContext<'a>> {
        __rule_children(self.__node, 85)
            .next()
            .map(|node| PredefinedTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_type(&self) -> Option<RefTypeContext<'a>> {
        __rule_children(self.__node, 86)
            .next()
            .map(|node| RefTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn scoped_type(&self) -> Option<ScopedTypeContext<'a>> {
        __rule_children(self.__node, 87)
            .next()
            .map(|node| ScopedTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn tuple_type(&self) -> Option<TupleTypeContext<'a>> {
        __rule_children(self.__node, 88)
            .next()
            .map(|node| TupleTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeContext<'a, ValidatedTreeContext> {
    pub fn name(&self) -> Option<NameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| NameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn array_rank_specifier_children(&self) -> impl Iterator<Item = ArrayRankSpecifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 78)
            .map(move |node| ArrayRankSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn function_pointer_type(&self) -> Option<FunctionPointerTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 79)
            .next()
            .map(|node| FunctionPointerTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn predefined_type(&self) -> Option<PredefinedTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 85)
            .next()
            .map(|node| PredefinedTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_type(&self) -> Option<RefTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 86)
            .next()
            .map(|node| RefTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn scoped_type(&self) -> Option<ScopedTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 87)
            .next()
            .map(|node| ScopedTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn tuple_type(&self) -> Option<TupleTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 88)
            .next()
            .map(|node| TupleTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrayTypeContext {
        rule_index: 77,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArrayTypeContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ArrayTypeContext", "type"))
    }
    pub fn array_rank_specifier_children(&self) -> impl Iterator<Item = ArrayRankSpecifierContext<'a>> + '_ {
        __rule_children(self.__node, 78)
            .map(move |node| ArrayRankSpecifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrayTypeContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated ArrayTypeContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn array_rank_specifier_children(&self) -> impl Iterator<Item = ArrayRankSpecifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 78)
            .map(move |node| ArrayRankSpecifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrayRankSpecifierContext {
        rule_index: 78,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArrayRankSpecifierContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrayRankSpecifierContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrayRankSpecifierContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrayRankSpecifierContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated ArrayRankSpecifierContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated ArrayRankSpecifierContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerTypeContext {
        rule_index: 79,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerTypeContext<'a, State> {
    pub fn function_pointer_calling_convention(&self) -> Option<FunctionPointerCallingConventionContext<'a>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| FunctionPointerCallingConventionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn function_pointer_parameter_list(&self) -> Result<FunctionPointerParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 83)
            .next()
            .map(|node| FunctionPointerParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FunctionPointerTypeContext", "function_pointer_parameter_list"))
    }
    pub fn kw_delegate_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerTypeContext", "KW_DELEGATE"))
    }
    pub fn star_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerTypeContext", "STAR"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerTypeContext<'a, ValidatedTreeContext> {
    pub fn function_pointer_calling_convention(&self) -> Option<FunctionPointerCallingConventionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| FunctionPointerCallingConventionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn function_pointer_parameter_list(&self) -> FunctionPointerParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 83).next() else {
            unreachable!("validated FunctionPointerTypeContext is missing required child function_pointer_parameter_list")
        };
        FunctionPointerParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_delegate_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 18).next() else {
            unreachable!("validated FunctionPointerTypeContext is missing required child KW_DELEGATE")
        };
        TerminalNode::new(node)
    }
    pub fn star_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 161).next() else {
            unreachable!("validated FunctionPointerTypeContext is missing required child STAR")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerCallingConventionContext {
        rule_index: 80,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerCallingConventionContext<'a, State> {
    pub fn function_pointer_unmanaged_calling_convention_list(&self) -> Option<FunctionPointerUnmanagedCallingConventionListContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| FunctionPointerUnmanagedCallingConventionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerCallingConventionContext<'a, ValidatedTreeContext> {
    pub fn function_pointer_unmanaged_calling_convention_list(&self) -> Option<FunctionPointerUnmanagedCallingConventionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| FunctionPointerUnmanagedCallingConventionListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerUnmanagedCallingConventionListContext {
        rule_index: 81,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerUnmanagedCallingConventionListContext<'a, State> {
    pub fn function_pointer_unmanaged_calling_convention_children(&self) -> impl Iterator<Item = FunctionPointerUnmanagedCallingConventionContext<'a>> + '_ {
        __rule_children(self.__node, 82)
            .map(move |node| FunctionPointerUnmanagedCallingConventionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerUnmanagedCallingConventionListContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerUnmanagedCallingConventionListContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerUnmanagedCallingConventionListContext<'a, ValidatedTreeContext> {
    pub fn function_pointer_unmanaged_calling_convention_children(&self) -> impl Iterator<Item = FunctionPointerUnmanagedCallingConventionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 82)
            .map(move |node| FunctionPointerUnmanagedCallingConventionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated FunctionPointerUnmanagedCallingConventionListContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated FunctionPointerUnmanagedCallingConventionListContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerUnmanagedCallingConventionContext {
        rule_index: 82,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerUnmanagedCallingConventionContext<'a, State> {
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FunctionPointerUnmanagedCallingConventionContext", "identifier_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerUnmanagedCallingConventionContext<'a, ValidatedTreeContext> {
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated FunctionPointerUnmanagedCallingConventionContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerParameterListContext {
        rule_index: 83,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerParameterListContext<'a, State> {
    pub fn function_pointer_parameter_children(&self) -> impl Iterator<Item = FunctionPointerParameterContext<'a>> + '_ {
        __rule_children(self.__node, 84)
            .map(move |node| FunctionPointerParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerParameterListContext", "LT"))
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FunctionPointerParameterListContext", "GT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerParameterListContext<'a, ValidatedTreeContext> {
    pub fn function_pointer_parameter_children(&self) -> impl Iterator<Item = FunctionPointerParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 84)
            .map(move |node| FunctionPointerParameterContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 168).next() else {
            unreachable!("validated FunctionPointerParameterListContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 170).next() else {
            unreachable!("validated FunctionPointerParameterListContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FunctionPointerParameterContext {
        rule_index: 84,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FunctionPointerParameterContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FunctionPointerParameterContext", "type"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FunctionPointerParameterContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated FunctionPointerParameterContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PredefinedTypeContext {
        rule_index: 85,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PredefinedTypeContext<'a, State> {
    pub fn kw_decimal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_object_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_string_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ushort_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sbyte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ulong_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_bool_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_uint_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PredefinedTypeContext<'a, ValidatedTreeContext> {
    pub fn kw_decimal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_object_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_string_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ushort_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sbyte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ulong_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_bool_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_uint_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RefTypeContext {
        rule_index: 86,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RefTypeContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RefTypeContext", "type"))
    }
    pub fn kw_readonly_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefTypeContext", "KW_REF"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RefTypeContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated RefTypeContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_readonly_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ref_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 116).next() else {
            unreachable!("validated RefTypeContext is missing required child KW_REF")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ScopedTypeContext {
        rule_index: 87,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ScopedTypeContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ScopedTypeContext", "type"))
    }
    pub fn kw_scoped_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ScopedTypeContext", "KW_SCOPED"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ScopedTypeContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated ScopedTypeContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_scoped_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 48).next() else {
            unreachable!("validated ScopedTypeContext is missing required child KW_SCOPED")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TupleTypeContext {
        rule_index: 88,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TupleTypeContext<'a, State> {
    pub fn tuple_element_children(&self) -> impl Iterator<Item = TupleElementContext<'a>> + '_ {
        __rule_children(self.__node, 89)
            .map(move |node| TupleElementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TupleTypeContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TupleTypeContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TupleTypeContext<'a, ValidatedTreeContext> {
    pub fn tuple_element_children(&self) -> impl Iterator<Item = TupleElementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 89)
            .map(move |node| TupleElementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated TupleTypeContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated TupleTypeContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TupleElementContext {
        rule_index: 89,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TupleElementContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TupleElementContext", "type"))
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TupleElementContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated TupleElementContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct StatementContext {
        rule_index: 90,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> StatementContext<'a, State> {
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn break_statement(&self) -> Option<BreakStatementContext<'a>> {
        __rule_children(self.__node, 91)
            .next()
            .map(|node| BreakStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn checked_statement(&self) -> Option<CheckedStatementContext<'a>> {
        __rule_children(self.__node, 92)
            .next()
            .map(|node| CheckedStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn common_for_each_statement(&self) -> Option<CommonForEachStatementContext<'a>> {
        __rule_children(self.__node, 93)
            .next()
            .map(|node| CommonForEachStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn continue_statement(&self) -> Option<ContinueStatementContext<'a>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ContinueStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn do_statement(&self) -> Option<DoStatementContext<'a>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| DoStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn empty_statement(&self) -> Option<EmptyStatementContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| EmptyStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_statement(&self) -> Option<ExpressionStatementContext<'a>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| ExpressionStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn fixed_statement(&self) -> Option<FixedStatementContext<'a>> {
        __rule_children(self.__node, 100)
            .next()
            .map(|node| FixedStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_statement(&self) -> Option<ForStatementContext<'a>> {
        __rule_children(self.__node, 101)
            .next()
            .map(|node| ForStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn goto_statement(&self) -> Option<GotoStatementContext<'a>> {
        __rule_children(self.__node, 102)
            .next()
            .map(|node| GotoStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn if_statement(&self) -> Option<IfStatementContext<'a>> {
        __rule_children(self.__node, 103)
            .next()
            .map(|node| IfStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn labeled_statement(&self) -> Option<LabeledStatementContext<'a>> {
        __rule_children(self.__node, 105)
            .next()
            .map(|node| LabeledStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_declaration_statement(&self) -> Option<LocalDeclarationStatementContext<'a>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| LocalDeclarationStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_function_statement(&self) -> Option<LocalFunctionStatementContext<'a>> {
        __rule_children(self.__node, 107)
            .next()
            .map(|node| LocalFunctionStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lock_statement(&self) -> Option<LockStatementContext<'a>> {
        __rule_children(self.__node, 108)
            .next()
            .map(|node| LockStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn return_statement(&self) -> Option<ReturnStatementContext<'a>> {
        __rule_children(self.__node, 109)
            .next()
            .map(|node| ReturnStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_statement(&self) -> Option<SwitchStatementContext<'a>> {
        __rule_children(self.__node, 110)
            .next()
            .map(|node| SwitchStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn throw_statement(&self) -> Option<ThrowStatementContext<'a>> {
        __rule_children(self.__node, 138)
            .next()
            .map(|node| ThrowStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn try_statement(&self) -> Option<TryStatementContext<'a>> {
        __rule_children(self.__node, 139)
            .next()
            .map(|node| TryStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsafe_statement(&self) -> Option<UnsafeStatementContext<'a>> {
        __rule_children(self.__node, 144)
            .next()
            .map(|node| UnsafeStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_statement(&self) -> Option<UsingStatementContext<'a>> {
        __rule_children(self.__node, 145)
            .next()
            .map(|node| UsingStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn while_statement(&self) -> Option<WhileStatementContext<'a>> {
        __rule_children(self.__node, 146)
            .next()
            .map(|node| WhileStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn yield_statement(&self) -> Option<YieldStatementContext<'a>> {
        __rule_children(self.__node, 147)
            .next()
            .map(|node| YieldStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> StatementContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn break_statement(&self) -> Option<BreakStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 91)
            .next()
            .map(|node| BreakStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn checked_statement(&self) -> Option<CheckedStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 92)
            .next()
            .map(|node| CheckedStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn common_for_each_statement(&self) -> Option<CommonForEachStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 93)
            .next()
            .map(|node| CommonForEachStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn continue_statement(&self) -> Option<ContinueStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ContinueStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn do_statement(&self) -> Option<DoStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| DoStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn empty_statement(&self) -> Option<EmptyStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| EmptyStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_statement(&self) -> Option<ExpressionStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| ExpressionStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn fixed_statement(&self) -> Option<FixedStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 100)
            .next()
            .map(|node| FixedStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_statement(&self) -> Option<ForStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 101)
            .next()
            .map(|node| ForStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn goto_statement(&self) -> Option<GotoStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 102)
            .next()
            .map(|node| GotoStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn if_statement(&self) -> Option<IfStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 103)
            .next()
            .map(|node| IfStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn labeled_statement(&self) -> Option<LabeledStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 105)
            .next()
            .map(|node| LabeledStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_declaration_statement(&self) -> Option<LocalDeclarationStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| LocalDeclarationStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_function_statement(&self) -> Option<LocalFunctionStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 107)
            .next()
            .map(|node| LocalFunctionStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lock_statement(&self) -> Option<LockStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 108)
            .next()
            .map(|node| LockStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn return_statement(&self) -> Option<ReturnStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 109)
            .next()
            .map(|node| ReturnStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_statement(&self) -> Option<SwitchStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 110)
            .next()
            .map(|node| SwitchStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn throw_statement(&self) -> Option<ThrowStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 138)
            .next()
            .map(|node| ThrowStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn try_statement(&self) -> Option<TryStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 139)
            .next()
            .map(|node| TryStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsafe_statement(&self) -> Option<UnsafeStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 144)
            .next()
            .map(|node| UnsafeStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn using_statement(&self) -> Option<UsingStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 145)
            .next()
            .map(|node| UsingStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn while_statement(&self) -> Option<WhileStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 146)
            .next()
            .map(|node| WhileStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn yield_statement(&self) -> Option<YieldStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 147)
            .next()
            .map(|node| YieldStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BreakStatementContext {
        rule_index: 91,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BreakStatementContext<'a, State> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_break_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BreakStatementContext", "KW_BREAK"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BreakStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BreakStatementContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_break_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 62).next() else {
            unreachable!("validated BreakStatementContext is missing required child KW_BREAK")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated BreakStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CheckedStatementContext {
        rule_index: 92,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CheckedStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CheckedStatementContext", "block"))
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CheckedStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated CheckedStatementContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CommonForEachStatementContext {
        rule_index: 93,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CommonForEachStatementContext<'a, State> {
    pub fn for_each_statement(&self) -> Option<ForEachStatementContext<'a>> {
        __rule_children(self.__node, 94)
            .next()
            .map(|node| ForEachStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_each_variable_statement(&self) -> Option<ForEachVariableStatementContext<'a>> {
        __rule_children(self.__node, 95)
            .next()
            .map(|node| ForEachVariableStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CommonForEachStatementContext<'a, ValidatedTreeContext> {
    pub fn for_each_statement(&self) -> Option<ForEachStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 94)
            .next()
            .map(|node| ForEachStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_each_variable_statement(&self) -> Option<ForEachVariableStatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 95)
            .next()
            .map(|node| ForEachVariableStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ForEachStatementContext {
        rule_index: 94,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ForEachStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "type"))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "statement"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "expression"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "identifier_token"))
    }
    pub fn kw_foreach_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "KW_FOREACH"))
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "KW_IN"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ForEachStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated ForEachStatementContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated ForEachStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ForEachStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated ForEachStatementContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_foreach_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 31).next() else {
            unreachable!("validated ForEachStatementContext is missing required child KW_FOREACH")
        };
        TerminalNode::new(node)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 149).next() else {
            unreachable!("validated ForEachStatementContext is missing required child KW_IN")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ForEachStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ForEachStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ForEachVariableStatementContext {
        rule_index: 95,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ForEachVariableStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForEachVariableStatementContext", "statement"))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_foreach_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachVariableStatementContext", "KW_FOREACH"))
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachVariableStatementContext", "KW_IN"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachVariableStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForEachVariableStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ForEachVariableStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated ForEachVariableStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_foreach_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 31).next() else {
            unreachable!("validated ForEachVariableStatementContext is missing required child KW_FOREACH")
        };
        TerminalNode::new(node)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 149).next() else {
            unreachable!("validated ForEachVariableStatementContext is missing required child KW_IN")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ForEachVariableStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ForEachVariableStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ContinueStatementContext {
        rule_index: 96,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ContinueStatementContext<'a, State> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_continue_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ContinueStatementContext", "KW_CONTINUE"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ContinueStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ContinueStatementContext<'a, ValidatedTreeContext> {
    pub fn identifier_name(&self) -> Option<IdentifierNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 4)
            .next()
            .map(|node| IdentifierNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_continue_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 17).next() else {
            unreachable!("validated ContinueStatementContext is missing required child KW_CONTINUE")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated ContinueStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DoStatementContext {
        rule_index: 97,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DoStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "statement"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "expression"))
    }
    pub fn kw_while_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "KW_WHILE"))
    }
    pub fn kw_do_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 147)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "KW_DO"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "SEMICOLON"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DoStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DoStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated DoStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated DoStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_while_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 79).next() else {
            unreachable!("validated DoStatementContext is missing required child KW_WHILE")
        };
        TerminalNode::new(node)
    }
    pub fn kw_do_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 147).next() else {
            unreachable!("validated DoStatementContext is missing required child KW_DO")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated DoStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated DoStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated DoStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EmptyStatementContext {
        rule_index: 98,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> EmptyStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EmptyStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EmptyStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated EmptyStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionStatementContext {
        rule_index: 99,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExpressionStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExpressionStatementContext", "expression"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExpressionStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ExpressionStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated ExpressionStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FixedStatementContext {
        rule_index: 100,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FixedStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Result<VariableDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FixedStatementContext", "variable_declaration"))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FixedStatementContext", "statement"))
    }
    pub fn kw_fixed_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 69)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FixedStatementContext", "KW_FIXED"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FixedStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FixedStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FixedStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> VariableDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 20).next() else {
            unreachable!("validated FixedStatementContext is missing required child variable_declaration")
        };
        VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated FixedStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_fixed_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 69).next() else {
            unreachable!("validated FixedStatementContext is missing required child KW_FIXED")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated FixedStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated FixedStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ForStatementContext {
        rule_index: 101,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ForStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Option<VariableDeclarationContext<'a>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ForStatementContext", "statement"))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_for_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForStatementContext", "KW_FOR"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn semicolon_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 167).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ForStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ForStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Option<VariableDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated ForStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_for_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 109).next() else {
            unreachable!("validated ForStatementContext is missing required child KW_FOR")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn semicolon_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 167).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ForStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ForStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GotoStatementContext {
        rule_index: 102,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> GotoStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_goto_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("GotoStatementContext", "KW_GOTO"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("GotoStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GotoStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_goto_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 90).next() else {
            unreachable!("validated GotoStatementContext is missing required child KW_GOTO")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated GotoStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IfStatementContext {
        rule_index: 103,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> IfStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("IfStatementContext", "statement"))
    }
    pub fn else_clause(&self) -> Option<ElseClauseContext<'a>> {
        __rule_children(self.__node, 104)
            .next()
            .map(|node| ElseClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("IfStatementContext", "expression"))
    }
    pub fn kw_if_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 148)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("IfStatementContext", "KW_IF"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("IfStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("IfStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IfStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated IfStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn else_clause(&self) -> Option<ElseClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 104)
            .next()
            .map(|node| ElseClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated IfStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_if_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 148).next() else {
            unreachable!("validated IfStatementContext is missing required child KW_IF")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated IfStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated IfStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ElseClauseContext {
        rule_index: 104,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ElseClauseContext<'a, State> {
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ElseClauseContext", "statement"))
    }
    pub fn kw_else_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 86)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ElseClauseContext", "KW_ELSE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ElseClauseContext<'a, ValidatedTreeContext> {
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated ElseClauseContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_else_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 86).next() else {
            unreachable!("validated ElseClauseContext is missing required child KW_ELSE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LabeledStatementContext {
        rule_index: 105,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LabeledStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LabeledStatementContext", "statement"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LabeledStatementContext", "identifier_token"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LabeledStatementContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LabeledStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated LabeledStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated LabeledStatementContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated LabeledStatementContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalDeclarationStatementContext {
        rule_index: 106,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LocalDeclarationStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_variable_declaration(&self) -> Result<LocalVariableDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 242)
            .next()
            .map(|node| LocalVariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalDeclarationStatementContext", "local_variable_declaration"))
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LocalDeclarationStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalDeclarationStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_variable_declaration(&self) -> LocalVariableDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 242).next() else {
            unreachable!("validated LocalDeclarationStatementContext is missing required child local_variable_declaration")
        };
        LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated LocalDeclarationStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalFunctionStatementContext {
        rule_index: 107,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LocalFunctionStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalFunctionStatementContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalFunctionStatementContext", "type"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalFunctionStatementContext", "identifier_token"))
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalFunctionStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated LocalFunctionStatementContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_expression_clause(&self) -> Option<ArrowExpressionClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_list(&self) -> Option<TypeParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 38)
            .next()
            .map(|node| TypeParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_parameter_constraint_clause_children(&self) -> impl Iterator<Item = TypeParameterConstraintClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated LocalFunctionStatementContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated LocalFunctionStatementContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LockStatementContext {
        rule_index: 108,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LockStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LockStatementContext", "statement"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LockStatementContext", "expression"))
    }
    pub fn kw_lock_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LockStatementContext", "KW_LOCK"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LockStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LockStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LockStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated LockStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated LockStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_lock_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 94).next() else {
            unreachable!("validated LockStatementContext is missing required child KW_LOCK")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated LockStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated LockStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ReturnStatementContext {
        rule_index: 109,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ReturnStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_return_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ReturnStatementContext", "KW_RETURN"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ReturnStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ReturnStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_return_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 47).next() else {
            unreachable!("validated ReturnStatementContext is missing required child KW_RETURN")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated ReturnStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchStatementContext {
        rule_index: 110,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SwitchStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_section_children(&self) -> impl Iterator<Item = SwitchSectionContext<'a>> + '_ {
        __rule_children(self.__node, 111)
            .map(move |node| SwitchSectionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "expression"))
    }
    pub fn kw_switch_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "KW_SWITCH"))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "RBRACE"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_section_children(&self) -> impl Iterator<Item = SwitchSectionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 111)
            .map(move |node| SwitchSectionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated SwitchStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_switch_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 55).next() else {
            unreachable!("validated SwitchStatementContext is missing required child KW_SWITCH")
        };
        TerminalNode::new(node)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated SwitchStatementContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated SwitchStatementContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated SwitchStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated SwitchStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchSectionContext {
        rule_index: 111,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SwitchSectionContext<'a, State> {
    pub fn statement_children(&self) -> impl Iterator<Item = StatementContext<'a>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_label_children(&self) -> impl Iterator<Item = SwitchLabelContext<'a>> + '_ {
        __rule_children(self.__node, 112)
            .map(move |node| SwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchSectionContext<'a, ValidatedTreeContext> {
    pub fn statement_children(&self) -> impl Iterator<Item = StatementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| StatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_label_children(&self) -> impl Iterator<Item = SwitchLabelContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 112)
            .map(move |node| SwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchLabelContext {
        rule_index: 112,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SwitchLabelContext<'a, State> {
    pub fn case_pattern_switch_label(&self) -> Option<CasePatternSwitchLabelContext<'a>> {
        __rule_children(self.__node, 113)
            .next()
            .map(|node| CasePatternSwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_switch_label(&self) -> Option<CaseSwitchLabelContext<'a>> {
        __rule_children(self.__node, 136)
            .next()
            .map(|node| CaseSwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_switch_label(&self) -> Option<DefaultSwitchLabelContext<'a>> {
        __rule_children(self.__node, 137)
            .next()
            .map(|node| DefaultSwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchLabelContext<'a, ValidatedTreeContext> {
    pub fn case_pattern_switch_label(&self) -> Option<CasePatternSwitchLabelContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 113)
            .next()
            .map(|node| CasePatternSwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_switch_label(&self) -> Option<CaseSwitchLabelContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 136)
            .next()
            .map(|node| CaseSwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_switch_label(&self) -> Option<DefaultSwitchLabelContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 137)
            .next()
            .map(|node| DefaultSwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CasePatternSwitchLabelContext {
        rule_index: 113,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CasePatternSwitchLabelContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CasePatternSwitchLabelContext", "pattern"))
    }
    pub fn when_clause(&self) -> Option<WhenClauseContext<'a>> {
        __rule_children(self.__node, 135)
            .next()
            .map(|node| WhenClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_case_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CasePatternSwitchLabelContext", "KW_CASE"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CasePatternSwitchLabelContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CasePatternSwitchLabelContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> PatternContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 114).next() else {
            unreachable!("validated CasePatternSwitchLabelContext is missing required child pattern")
        };
        PatternContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn when_clause(&self) -> Option<WhenClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 135)
            .next()
            .map(|node| WhenClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_case_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 84).next() else {
            unreachable!("validated CasePatternSwitchLabelContext is missing required child KW_CASE")
        };
        TerminalNode::new(node)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated CasePatternSwitchLabelContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PatternContext {
        rule_index: 114,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PatternContext<'a, State> {
    pub fn pattern_children(&self) -> impl Iterator<Item = PatternContext<'a>> + '_ {
        __rule_children(self.__node, 114)
            .map(move |node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constant_pattern(&self) -> Option<ConstantPatternContext<'a>> {
        __rule_children(self.__node, 115)
            .next()
            .map(|node| ConstantPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn declaration_pattern(&self) -> Option<DeclarationPatternContext<'a>> {
        __rule_children(self.__node, 116)
            .next()
            .map(|node| DeclarationPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn discard_pattern(&self) -> Option<DiscardPatternContext<'a>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| DiscardPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn list_pattern(&self) -> Option<ListPatternContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| ListPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_pattern(&self) -> Option<ParenthesizedPatternContext<'a>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| ParenthesizedPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn recursive_pattern(&self) -> Option<RecursivePatternContext<'a>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| RecursivePatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn relational_pattern(&self) -> Option<RelationalPatternContext<'a>> {
        __rule_children(self.__node, 130)
            .next()
            .map(|node| RelationalPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn slice_pattern(&self) -> Option<SlicePatternContext<'a>> {
        __rule_children(self.__node, 131)
            .next()
            .map(|node| SlicePatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_pattern(&self) -> Option<TypePatternContext<'a>> {
        __rule_children(self.__node, 132)
            .next()
            .map(|node| TypePatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unary_pattern(&self) -> Option<UnaryPatternContext<'a>> {
        __rule_children(self.__node, 133)
            .next()
            .map(|node| UnaryPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_pattern(&self) -> Option<VarPatternContext<'a>> {
        __rule_children(self.__node, 134)
            .next()
            .map(|node| VarPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 152)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PatternContext<'a, ValidatedTreeContext> {
    pub fn pattern_children(&self) -> impl Iterator<Item = PatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 114)
            .map(move |node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constant_pattern(&self) -> Option<ConstantPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 115)
            .next()
            .map(|node| ConstantPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn declaration_pattern(&self) -> Option<DeclarationPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 116)
            .next()
            .map(|node| DeclarationPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn discard_pattern(&self) -> Option<DiscardPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| DiscardPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn list_pattern(&self) -> Option<ListPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| ListPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_pattern(&self) -> Option<ParenthesizedPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| ParenthesizedPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn recursive_pattern(&self) -> Option<RecursivePatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| RecursivePatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn relational_pattern(&self) -> Option<RelationalPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 130)
            .next()
            .map(|node| RelationalPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn slice_pattern(&self) -> Option<SlicePatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 131)
            .next()
            .map(|node| SlicePatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_pattern(&self) -> Option<TypePatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 132)
            .next()
            .map(|node| TypePatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unary_pattern(&self) -> Option<UnaryPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 133)
            .next()
            .map(|node| UnaryPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_pattern(&self) -> Option<VarPatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 134)
            .next()
            .map(|node| VarPatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 152)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstantPatternContext {
        rule_index: 115,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ConstantPatternContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstantPatternContext", "expression"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstantPatternContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ConstantPatternContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DeclarationPatternContext {
        rule_index: 116,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DeclarationPatternContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DeclarationPatternContext", "type"))
    }
    pub fn variable_designation(&self) -> Result<VariableDesignationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DeclarationPatternContext", "variable_designation"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DeclarationPatternContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated DeclarationPatternContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn variable_designation(&self) -> VariableDesignationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 117).next() else {
            unreachable!("validated DeclarationPatternContext is missing required child variable_designation")
        };
        VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDesignationContext {
        rule_index: 117,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> VariableDesignationContext<'a, State> {
    pub fn discard_designation(&self) -> Option<DiscardDesignationContext<'a>> {
        __rule_children(self.__node, 118)
            .next()
            .map(|node| DiscardDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_variable_designation(&self) -> Option<ParenthesizedVariableDesignationContext<'a>> {
        __rule_children(self.__node, 119)
            .next()
            .map(|node| ParenthesizedVariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn single_variable_designation(&self) -> Option<SingleVariableDesignationContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| SingleVariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDesignationContext<'a, ValidatedTreeContext> {
    pub fn discard_designation(&self) -> Option<DiscardDesignationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 118)
            .next()
            .map(|node| DiscardDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_variable_designation(&self) -> Option<ParenthesizedVariableDesignationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 119)
            .next()
            .map(|node| ParenthesizedVariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn single_variable_designation(&self) -> Option<SingleVariableDesignationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| SingleVariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DiscardDesignationContext {
        rule_index: 118,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DiscardDesignationContext<'a, State> {
    pub fn kw_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DiscardDesignationContext", "KW__"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DiscardDesignationContext<'a, ValidatedTreeContext> {
    pub fn kw_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 173).next() else {
            unreachable!("validated DiscardDesignationContext is missing required child KW__")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParenthesizedVariableDesignationContext {
        rule_index: 119,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParenthesizedVariableDesignationContext<'a, State> {
    pub fn variable_designation_children(&self) -> impl Iterator<Item = VariableDesignationContext<'a>> + '_ {
        __rule_children(self.__node, 117)
            .map(move |node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedVariableDesignationContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedVariableDesignationContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParenthesizedVariableDesignationContext<'a, ValidatedTreeContext> {
    pub fn variable_designation_children(&self) -> impl Iterator<Item = VariableDesignationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 117)
            .map(move |node| VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ParenthesizedVariableDesignationContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ParenthesizedVariableDesignationContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SingleVariableDesignationContext {
        rule_index: 120,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SingleVariableDesignationContext<'a, State> {
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extension_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 10)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_orderby_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_allows_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_equals_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_select_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_alias_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_field_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_group_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_union_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_where_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_from_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_into_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_join_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_let_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_by_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 146)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_on_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 151)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 176)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 177)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SingleVariableDesignationContext<'a, ValidatedTreeContext> {
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extension_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 10)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_orderby_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_allows_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_equals_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_select_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_alias_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_field_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_group_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_union_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_where_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_from_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_into_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_join_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_let_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_by_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 146)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_on_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 151)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 176)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 177)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DiscardPatternContext {
        rule_index: 121,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DiscardPatternContext<'a, State> {
    pub fn kw_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DiscardPatternContext", "KW__"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DiscardPatternContext<'a, ValidatedTreeContext> {
    pub fn kw_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 173).next() else {
            unreachable!("validated DiscardPatternContext is missing required child KW__")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ListPatternContext {
        rule_index: 122,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ListPatternContext<'a, State> {
    pub fn pattern_children(&self) -> impl Iterator<Item = PatternContext<'a>> + '_ {
        __rule_children(self.__node, 114)
            .map(move |node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_designation(&self) -> Option<VariableDesignationContext<'a>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ListPatternContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ListPatternContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ListPatternContext<'a, ValidatedTreeContext> {
    pub fn pattern_children(&self) -> impl Iterator<Item = PatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 114)
            .map(move |node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_designation(&self) -> Option<VariableDesignationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated ListPatternContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated ListPatternContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParenthesizedPatternContext {
        rule_index: 123,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParenthesizedPatternContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ParenthesizedPatternContext", "pattern"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedPatternContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedPatternContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParenthesizedPatternContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> PatternContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 114).next() else {
            unreachable!("validated ParenthesizedPatternContext is missing required child pattern")
        };
        PatternContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ParenthesizedPatternContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ParenthesizedPatternContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecursivePatternContext {
        rule_index: 124,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RecursivePatternContext<'a, State> {
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_designation(&self) -> Option<VariableDesignationContext<'a>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn positional_pattern_clause(&self) -> Option<PositionalPatternClauseContext<'a>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| PositionalPatternClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn property_pattern_clause(&self) -> Option<PropertyPatternClauseContext<'a>> {
        __rule_children(self.__node, 129)
            .next()
            .map(|node| PropertyPatternClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecursivePatternContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_designation(&self) -> Option<VariableDesignationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn positional_pattern_clause(&self) -> Option<PositionalPatternClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| PositionalPatternClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn property_pattern_clause(&self) -> Option<PropertyPatternClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 129)
            .next()
            .map(|node| PropertyPatternClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PositionalPatternClauseContext {
        rule_index: 125,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PositionalPatternClauseContext<'a, State> {
    pub fn subpattern_children(&self) -> impl Iterator<Item = SubpatternContext<'a>> + '_ {
        __rule_children(self.__node, 126)
            .map(move |node| SubpatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PositionalPatternClauseContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PositionalPatternClauseContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PositionalPatternClauseContext<'a, ValidatedTreeContext> {
    pub fn subpattern_children(&self) -> impl Iterator<Item = SubpatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 126)
            .map(move |node| SubpatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated PositionalPatternClauseContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated PositionalPatternClauseContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SubpatternContext {
        rule_index: 126,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SubpatternContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SubpatternContext", "pattern"))
    }
    pub fn base_expression_colon(&self) -> Option<BaseExpressionColonContext<'a>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| BaseExpressionColonContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SubpatternContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> PatternContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 114).next() else {
            unreachable!("validated SubpatternContext is missing required child pattern")
        };
        PatternContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn base_expression_colon(&self) -> Option<BaseExpressionColonContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| BaseExpressionColonContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseExpressionColonContext {
        rule_index: 127,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseExpressionColonContext<'a, State> {
    pub fn name_colon(&self) -> Option<NameColonContext<'a>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_colon(&self) -> Option<ExpressionColonContext<'a>> {
        __rule_children(self.__node, 128)
            .next()
            .map(|node| ExpressionColonContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseExpressionColonContext<'a, ValidatedTreeContext> {
    pub fn name_colon(&self) -> Option<NameColonContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| NameColonContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_colon(&self) -> Option<ExpressionColonContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 128)
            .next()
            .map(|node| ExpressionColonContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionColonContext {
        rule_index: 128,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExpressionColonContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExpressionColonContext", "expression"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ExpressionColonContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionColonContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ExpressionColonContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated ExpressionColonContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PropertyPatternClauseContext {
        rule_index: 129,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PropertyPatternClauseContext<'a, State> {
    pub fn subpattern_children(&self) -> impl Iterator<Item = SubpatternContext<'a>> + '_ {
        __rule_children(self.__node, 126)
            .map(move |node| SubpatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PropertyPatternClauseContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PropertyPatternClauseContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PropertyPatternClauseContext<'a, ValidatedTreeContext> {
    pub fn subpattern_children(&self) -> impl Iterator<Item = SubpatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 126)
            .map(move |node| SubpatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated PropertyPatternClauseContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated PropertyPatternClauseContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RelationalPatternContext {
        rule_index: 130,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RelationalPatternContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RelationalPatternContext", "expression"))
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RelationalPatternContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated RelationalPatternContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SlicePatternContext {
        rule_index: 131,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SlicePatternContext<'a, State> {
    pub fn pattern(&self) -> Option<PatternContext<'a>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_dot_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SlicePatternContext", "DOT_DOT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SlicePatternContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> Option<PatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_dot_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 130).next() else {
            unreachable!("validated SlicePatternContext is missing required child DOT_DOT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypePatternContext {
        rule_index: 132,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypePatternContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypePatternContext", "type"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypePatternContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated TypePatternContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnaryPatternContext {
        rule_index: 133,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnaryPatternContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UnaryPatternContext", "pattern"))
    }
    pub fn kw_not_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnaryPatternContext", "KW_NOT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnaryPatternContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> PatternContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 114).next() else {
            unreachable!("validated UnaryPatternContext is missing required child pattern")
        };
        PatternContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_not_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 114).next() else {
            unreachable!("validated UnaryPatternContext is missing required child KW_NOT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VarPatternContext {
        rule_index: 134,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> VarPatternContext<'a, State> {
    pub fn variable_designation(&self) -> Result<VariableDesignationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("VarPatternContext", "variable_designation"))
    }
    pub fn kw_var_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("VarPatternContext", "KW_VAR"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VarPatternContext<'a, ValidatedTreeContext> {
    pub fn variable_designation(&self) -> VariableDesignationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 117).next() else {
            unreachable!("validated VarPatternContext is missing required child variable_designation")
        };
        VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_var_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 119).next() else {
            unreachable!("validated VarPatternContext is missing required child KW_VAR")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct WhenClauseContext {
        rule_index: 135,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> WhenClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("WhenClauseContext", "expression"))
    }
    pub fn kw_when_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WhenClauseContext", "KW_WHEN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> WhenClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated WhenClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_when_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 102).next() else {
            unreachable!("validated WhenClauseContext is missing required child KW_WHEN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CaseSwitchLabelContext {
        rule_index: 136,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CaseSwitchLabelContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CaseSwitchLabelContext", "expression"))
    }
    pub fn kw_case_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CaseSwitchLabelContext", "KW_CASE"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CaseSwitchLabelContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CaseSwitchLabelContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated CaseSwitchLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_case_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 84).next() else {
            unreachable!("validated CaseSwitchLabelContext is missing required child KW_CASE")
        };
        TerminalNode::new(node)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated CaseSwitchLabelContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DefaultSwitchLabelContext {
        rule_index: 137,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DefaultSwitchLabelContext<'a, State> {
    pub fn kw_default_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultSwitchLabelContext", "KW_DEFAULT"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultSwitchLabelContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DefaultSwitchLabelContext<'a, ValidatedTreeContext> {
    pub fn kw_default_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 29).next() else {
            unreachable!("validated DefaultSwitchLabelContext is missing required child KW_DEFAULT")
        };
        TerminalNode::new(node)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated DefaultSwitchLabelContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ThrowStatementContext {
        rule_index: 138,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ThrowStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_throw_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ThrowStatementContext", "KW_THROW"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ThrowStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ThrowStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_throw_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 74).next() else {
            unreachable!("validated ThrowStatementContext is missing required child KW_THROW")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated ThrowStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TryStatementContext {
        rule_index: 139,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TryStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TryStatementContext", "block"))
    }
    pub fn catch_clause_children(&self) -> impl Iterator<Item = CatchClauseContext<'a>> + '_ {
        __rule_children(self.__node, 140)
            .map(move |node| CatchClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn finally_clause(&self) -> Option<FinallyClauseContext<'a>> {
        __rule_children(self.__node, 143)
            .next()
            .map(|node| FinallyClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_try_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TryStatementContext", "KW_TRY"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TryStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated TryStatementContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn catch_clause_children(&self) -> impl Iterator<Item = CatchClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 140)
            .map(move |node| CatchClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn finally_clause(&self) -> Option<FinallyClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 143)
            .next()
            .map(|node| FinallyClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_try_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 118).next() else {
            unreachable!("validated TryStatementContext is missing required child KW_TRY")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CatchClauseContext {
        rule_index: 140,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CatchClauseContext<'a, State> {
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "block"))
    }
    pub fn catch_declaration(&self) -> Option<CatchDeclarationContext<'a>> {
        __rule_children(self.__node, 141)
            .next()
            .map(|node| CatchDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn catch_filter_clause(&self) -> Option<CatchFilterClauseContext<'a>> {
        __rule_children(self.__node, 142)
            .next()
            .map(|node| CatchFilterClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_catch_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 63)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "KW_CATCH"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CatchClauseContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated CatchClauseContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn catch_declaration(&self) -> Option<CatchDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 141)
            .next()
            .map(|node| CatchDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn catch_filter_clause(&self) -> Option<CatchFilterClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 142)
            .next()
            .map(|node| CatchFilterClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_catch_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 63).next() else {
            unreachable!("validated CatchClauseContext is missing required child KW_CATCH")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CatchDeclarationContext {
        rule_index: 141,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CatchDeclarationContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchDeclarationContext", "type"))
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchDeclarationContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchDeclarationContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CatchDeclarationContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated CatchDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated CatchDeclarationContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated CatchDeclarationContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CatchFilterClauseContext {
        rule_index: 142,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CatchFilterClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchFilterClauseContext", "expression"))
    }
    pub fn kw_when_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchFilterClauseContext", "KW_WHEN"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchFilterClauseContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchFilterClauseContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CatchFilterClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated CatchFilterClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_when_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 102).next() else {
            unreachable!("validated CatchFilterClauseContext is missing required child KW_WHEN")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated CatchFilterClauseContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated CatchFilterClauseContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FinallyClauseContext {
        rule_index: 143,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FinallyClauseContext<'a, State> {
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FinallyClauseContext", "block"))
    }
    pub fn kw_finally_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 30)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FinallyClauseContext", "KW_FINALLY"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FinallyClauseContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated FinallyClauseContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_finally_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 30).next() else {
            unreachable!("validated FinallyClauseContext is missing required child KW_FINALLY")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnsafeStatementContext {
        rule_index: 144,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnsafeStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UnsafeStatementContext", "block"))
    }
    pub fn kw_unsafe_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnsafeStatementContext", "KW_UNSAFE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnsafeStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated UnsafeStatementContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_unsafe_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 57).next() else {
            unreachable!("validated UnsafeStatementContext is missing required child KW_UNSAFE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UsingStatementContext {
        rule_index: 145,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UsingStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Option<VariableDeclarationContext<'a>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UsingStatementContext", "statement"))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UsingStatementContext", "KW_USING"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UsingStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UsingStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UsingStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declaration(&self) -> Option<VariableDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated UsingStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 77).next() else {
            unreachable!("validated UsingStatementContext is missing required child KW_USING")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated UsingStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated UsingStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct WhileStatementContext {
        rule_index: 146,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> WhileStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Result<StatementContext<'a>, MissingChildError> {
        __rule_children(self.__node, 90)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("WhileStatementContext", "statement"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("WhileStatementContext", "expression"))
    }
    pub fn kw_while_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WhileStatementContext", "KW_WHILE"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WhileStatementContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WhileStatementContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> WhileStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> StatementContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 90).next() else {
            unreachable!("validated WhileStatementContext is missing required child statement")
        };
        StatementContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated WhileStatementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_while_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 79).next() else {
            unreachable!("validated WhileStatementContext is missing required child KW_WHILE")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated WhileStatementContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated WhileStatementContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct YieldStatementContext {
        rule_index: 147,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> YieldStatementContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("YieldStatementContext", "KW_YIELD"))
    }
    pub fn semicolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("YieldStatementContext", "SEMICOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> YieldStatementContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated YieldStatementContext is missing required child KW_YIELD")
        };
        TerminalNode::new(node)
    }
    pub fn semicolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 167).next() else {
            unreachable!("validated YieldStatementContext is missing required child SEMICOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionContext {
        rule_index: 148,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExpressionContext<'a, State> {
    pub fn simple_name(&self) -> Option<SimpleNameContext<'a>> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bracketed_argument_list(&self) -> Option<BracketedArgumentListContext<'a>> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn argument_list(&self) -> Option<ArgumentListContext<'a>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn pattern(&self) -> Option<PatternContext<'a>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn anonymous_function_expression(&self) -> Option<AnonymousFunctionExpressionContext<'a>> {
        __rule_children(self.__node, 149)
            .next()
            .map(|node| AnonymousFunctionExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn anonymous_object_creation_expression(&self) -> Option<AnonymousObjectCreationExpressionContext<'a>> {
        __rule_children(self.__node, 154)
            .next()
            .map(|node| AnonymousObjectCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn array_creation_expression(&self) -> Option<ArrayCreationExpressionContext<'a>> {
        __rule_children(self.__node, 156)
            .next()
            .map(|node| ArrayCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn await_expression(&self) -> Option<AwaitExpressionContext<'a>> {
        __rule_children(self.__node, 158)
            .next()
            .map(|node| AwaitExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_object_creation_expression(&self) -> Option<BaseObjectCreationExpressionContext<'a>> {
        __rule_children(self.__node, 159)
            .next()
            .map(|node| BaseObjectCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn cast_expression(&self) -> Option<CastExpressionContext<'a>> {
        __rule_children(self.__node, 162)
            .next()
            .map(|node| CastExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn checked_expression(&self) -> Option<CheckedExpressionContext<'a>> {
        __rule_children(self.__node, 163)
            .next()
            .map(|node| CheckedExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn collection_expression(&self) -> Option<CollectionExpressionContext<'a>> {
        __rule_children(self.__node, 164)
            .next()
            .map(|node| CollectionExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn declaration_expression(&self) -> Option<DeclarationExpressionContext<'a>> {
        __rule_children(self.__node, 169)
            .next()
            .map(|node| DeclarationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_expression(&self) -> Option<DefaultExpressionContext<'a>> {
        __rule_children(self.__node, 170)
            .next()
            .map(|node| DefaultExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn element_binding_expression(&self) -> Option<ElementBindingExpressionContext<'a>> {
        __rule_children(self.__node, 171)
            .next()
            .map(|node| ElementBindingExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_expression(&self) -> Option<FieldExpressionContext<'a>> {
        __rule_children(self.__node, 172)
            .next()
            .map(|node| FieldExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_array_creation_expression(&self) -> Option<ImplicitArrayCreationExpressionContext<'a>> {
        __rule_children(self.__node, 173)
            .next()
            .map(|node| ImplicitArrayCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_element_access(&self) -> Option<ImplicitElementAccessContext<'a>> {
        __rule_children(self.__node, 174)
            .next()
            .map(|node| ImplicitElementAccessContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_stack_alloc_array_creation_expression(&self) -> Option<ImplicitStackAllocArrayCreationExpressionContext<'a>> {
        __rule_children(self.__node, 175)
            .next()
            .map(|node| ImplicitStackAllocArrayCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instance_expression(&self) -> Option<InstanceExpressionContext<'a>> {
        __rule_children(self.__node, 176)
            .next()
            .map(|node| InstanceExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_string_expression(&self) -> Option<InterpolatedStringExpressionContext<'a>> {
        __rule_children(self.__node, 179)
            .next()
            .map(|node| InterpolatedStringExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn literal_expression(&self) -> Option<LiteralExpressionContext<'a>> {
        __rule_children(self.__node, 188)
            .next()
            .map(|node| LiteralExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn make_ref_expression(&self) -> Option<MakeRefExpressionContext<'a>> {
        __rule_children(self.__node, 192)
            .next()
            .map(|node| MakeRefExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_binding_expression(&self) -> Option<MemberBindingExpressionContext<'a>> {
        __rule_children(self.__node, 193)
            .next()
            .map(|node| MemberBindingExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_expression(&self) -> Option<ParenthesizedExpressionContext<'a>> {
        __rule_children(self.__node, 194)
            .next()
            .map(|node| ParenthesizedExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn prefix_unary_expression(&self) -> Option<PrefixUnaryExpressionContext<'a>> {
        __rule_children(self.__node, 195)
            .next()
            .map(|node| PrefixUnaryExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn query_expression(&self) -> Option<QueryExpressionContext<'a>> {
        __rule_children(self.__node, 196)
            .next()
            .map(|node| QueryExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_expression(&self) -> Option<RefExpressionContext<'a>> {
        __rule_children(self.__node, 210)
            .next()
            .map(|node| RefExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_type_expression(&self) -> Option<RefTypeExpressionContext<'a>> {
        __rule_children(self.__node, 211)
            .next()
            .map(|node| RefTypeExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_value_expression(&self) -> Option<RefValueExpressionContext<'a>> {
        __rule_children(self.__node, 212)
            .next()
            .map(|node| RefValueExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn size_of_expression(&self) -> Option<SizeOfExpressionContext<'a>> {
        __rule_children(self.__node, 213)
            .next()
            .map(|node| SizeOfExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn stack_alloc_array_creation_expression(&self) -> Option<StackAllocArrayCreationExpressionContext<'a>> {
        __rule_children(self.__node, 214)
            .next()
            .map(|node| StackAllocArrayCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression_arm_children(&self) -> impl Iterator<Item = SwitchExpressionArmContext<'a>> + '_ {
        __rule_children(self.__node, 215)
            .map(move |node| SwitchExpressionArmContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn throw_expression(&self) -> Option<ThrowExpressionContext<'a>> {
        __rule_children(self.__node, 216)
            .next()
            .map(|node| ThrowExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn tuple_expression(&self) -> Option<TupleExpressionContext<'a>> {
        __rule_children(self.__node, 217)
            .next()
            .map(|node| TupleExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_of_expression(&self) -> Option<TypeOfExpressionContext<'a>> {
        __rule_children(self.__node, 218)
            .next()
            .map(|node| TypeOfExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsafe_expression(&self) -> Option<UnsafeExpressionContext<'a>> {
        __rule_children(self.__node, 219)
            .next()
            .map(|node| UnsafeExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift(&self) -> Option<RightShiftContext<'a>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 140)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 155)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionContext<'a, ValidatedTreeContext> {
    pub fn simple_name(&self) -> Option<SimpleNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bracketed_argument_list(&self) -> Option<BracketedArgumentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn argument_list(&self) -> Option<ArgumentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn pattern(&self) -> Option<PatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn anonymous_function_expression(&self) -> Option<AnonymousFunctionExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 149)
            .next()
            .map(|node| AnonymousFunctionExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn anonymous_object_creation_expression(&self) -> Option<AnonymousObjectCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 154)
            .next()
            .map(|node| AnonymousObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn array_creation_expression(&self) -> Option<ArrayCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 156)
            .next()
            .map(|node| ArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn await_expression(&self) -> Option<AwaitExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 158)
            .next()
            .map(|node| AwaitExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn base_object_creation_expression(&self) -> Option<BaseObjectCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 159)
            .next()
            .map(|node| BaseObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn cast_expression(&self) -> Option<CastExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 162)
            .next()
            .map(|node| CastExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn checked_expression(&self) -> Option<CheckedExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 163)
            .next()
            .map(|node| CheckedExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn collection_expression(&self) -> Option<CollectionExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 164)
            .next()
            .map(|node| CollectionExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn declaration_expression(&self) -> Option<DeclarationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 169)
            .next()
            .map(|node| DeclarationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn default_expression(&self) -> Option<DefaultExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 170)
            .next()
            .map(|node| DefaultExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn element_binding_expression(&self) -> Option<ElementBindingExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 171)
            .next()
            .map(|node| ElementBindingExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_expression(&self) -> Option<FieldExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 172)
            .next()
            .map(|node| FieldExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_array_creation_expression(&self) -> Option<ImplicitArrayCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 173)
            .next()
            .map(|node| ImplicitArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_element_access(&self) -> Option<ImplicitElementAccessContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 174)
            .next()
            .map(|node| ImplicitElementAccessContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implicit_stack_alloc_array_creation_expression(&self) -> Option<ImplicitStackAllocArrayCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 175)
            .next()
            .map(|node| ImplicitStackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instance_expression(&self) -> Option<InstanceExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 176)
            .next()
            .map(|node| InstanceExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_string_expression(&self) -> Option<InterpolatedStringExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 179)
            .next()
            .map(|node| InterpolatedStringExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn literal_expression(&self) -> Option<LiteralExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 188)
            .next()
            .map(|node| LiteralExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn make_ref_expression(&self) -> Option<MakeRefExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 192)
            .next()
            .map(|node| MakeRefExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_binding_expression(&self) -> Option<MemberBindingExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 193)
            .next()
            .map(|node| MemberBindingExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parenthesized_expression(&self) -> Option<ParenthesizedExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 194)
            .next()
            .map(|node| ParenthesizedExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn prefix_unary_expression(&self) -> Option<PrefixUnaryExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 195)
            .next()
            .map(|node| PrefixUnaryExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn query_expression(&self) -> Option<QueryExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 196)
            .next()
            .map(|node| QueryExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_expression(&self) -> Option<RefExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 210)
            .next()
            .map(|node| RefExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_type_expression(&self) -> Option<RefTypeExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 211)
            .next()
            .map(|node| RefTypeExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn ref_value_expression(&self) -> Option<RefValueExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 212)
            .next()
            .map(|node| RefValueExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn size_of_expression(&self) -> Option<SizeOfExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 213)
            .next()
            .map(|node| SizeOfExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn stack_alloc_array_creation_expression(&self) -> Option<StackAllocArrayCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 214)
            .next()
            .map(|node| StackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression_arm_children(&self) -> impl Iterator<Item = SwitchExpressionArmContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 215)
            .map(move |node| SwitchExpressionArmContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn throw_expression(&self) -> Option<ThrowExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 216)
            .next()
            .map(|node| ThrowExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn tuple_expression(&self) -> Option<TupleExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 217)
            .next()
            .map(|node| TupleExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_of_expression(&self) -> Option<TypeOfExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 218)
            .next()
            .map(|node| TypeOfExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsafe_expression(&self) -> Option<UnsafeExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 219)
            .next()
            .map(|node| UnsafeExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift(&self) -> Option<RightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 140)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 155)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnonymousFunctionExpressionContext {
        rule_index: 149,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AnonymousFunctionExpressionContext<'a, State> {
    pub fn anonymous_method_expression(&self) -> Option<AnonymousMethodExpressionContext<'a>> {
        __rule_children(self.__node, 150)
            .next()
            .map(|node| AnonymousMethodExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_expression(&self) -> Option<LambdaExpressionContext<'a>> {
        __rule_children(self.__node, 151)
            .next()
            .map(|node| LambdaExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnonymousFunctionExpressionContext<'a, ValidatedTreeContext> {
    pub fn anonymous_method_expression(&self) -> Option<AnonymousMethodExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 150)
            .next()
            .map(|node| AnonymousMethodExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_expression(&self) -> Option<LambdaExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 151)
            .next()
            .map(|node| LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnonymousMethodExpressionContext {
        rule_index: 150,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AnonymousMethodExpressionContext<'a, State> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnonymousMethodExpressionContext", "block"))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_delegate_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnonymousMethodExpressionContext", "KW_DELEGATE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnonymousMethodExpressionContext<'a, ValidatedTreeContext> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Option<ParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 32).next() else {
            unreachable!("validated AnonymousMethodExpressionContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_delegate_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 18).next() else {
            unreachable!("validated AnonymousMethodExpressionContext is missing required child KW_DELEGATE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaExpressionContext {
        rule_index: 151,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LambdaExpressionContext<'a, State> {
    pub fn parenthesized_lambda_expression(&self) -> Option<ParenthesizedLambdaExpressionContext<'a>> {
        __rule_children(self.__node, 152)
            .next()
            .map(|node| ParenthesizedLambdaExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_lambda_expression(&self) -> Option<SimpleLambdaExpressionContext<'a>> {
        __rule_children(self.__node, 153)
            .next()
            .map(|node| SimpleLambdaExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaExpressionContext<'a, ValidatedTreeContext> {
    pub fn parenthesized_lambda_expression(&self) -> Option<ParenthesizedLambdaExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 152)
            .next()
            .map(|node| ParenthesizedLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn simple_lambda_expression(&self) -> Option<SimpleLambdaExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 153)
            .next()
            .map(|node| SimpleLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParenthesizedLambdaExpressionContext {
        rule_index: 152,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParenthesizedLambdaExpressionContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> Result<ParameterListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| ParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ParenthesizedLambdaExpressionContext", "parameter_list"))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedLambdaExpressionContext", "ARROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParenthesizedLambdaExpressionContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn parameter_list(&self) -> ParameterListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 28).next() else {
            unreachable!("validated ParenthesizedLambdaExpressionContext is missing required child parameter_list")
        };
        ParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arrow_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 138).next() else {
            unreachable!("validated ParenthesizedLambdaExpressionContext is missing required child ARROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SimpleLambdaExpressionContext {
        rule_index: 153,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SimpleLambdaExpressionContext<'a, State> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SimpleLambdaExpressionContext", "identifier_token"))
    }
    pub fn arrow_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SimpleLambdaExpressionContext", "ARROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SimpleLambdaExpressionContext<'a, ValidatedTreeContext> {
    pub fn attribute_list_children(&self) -> impl Iterator<Item = AttributeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| AttributeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 32)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated SimpleLambdaExpressionContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn arrow_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 138).next() else {
            unreachable!("validated SimpleLambdaExpressionContext is missing required child ARROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnonymousObjectCreationExpressionContext {
        rule_index: 154,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AnonymousObjectCreationExpressionContext<'a, State> {
    pub fn anonymous_object_member_declarator_children(&self) -> impl Iterator<Item = AnonymousObjectMemberDeclaratorContext<'a>> + '_ {
        __rule_children(self.__node, 155)
            .map(move |node| AnonymousObjectMemberDeclaratorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnonymousObjectCreationExpressionContext", "KW_NEW"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnonymousObjectCreationExpressionContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnonymousObjectCreationExpressionContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnonymousObjectCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn anonymous_object_member_declarator_children(&self) -> impl Iterator<Item = AnonymousObjectMemberDeclaratorContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 155)
            .map(move |node| AnonymousObjectMemberDeclaratorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated AnonymousObjectCreationExpressionContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated AnonymousObjectCreationExpressionContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated AnonymousObjectCreationExpressionContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnonymousObjectMemberDeclaratorContext {
        rule_index: 155,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AnonymousObjectMemberDeclaratorContext<'a, State> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnonymousObjectMemberDeclaratorContext", "expression"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnonymousObjectMemberDeclaratorContext<'a, ValidatedTreeContext> {
    pub fn name_equals(&self) -> Option<NameEqualsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 3)
            .next()
            .map(|node| NameEqualsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated AnonymousObjectMemberDeclaratorContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrayCreationExpressionContext {
        rule_index: 156,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ArrayCreationExpressionContext<'a, State> {
    pub fn array_type(&self) -> Result<ArrayTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 77)
            .next()
            .map(|node| ArrayTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ArrayCreationExpressionContext", "array_type"))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrayCreationExpressionContext", "KW_NEW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrayCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn array_type(&self) -> ArrayTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 77).next() else {
            unreachable!("validated ArrayCreationExpressionContext is missing required child array_type")
        };
        ArrayTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated ArrayCreationExpressionContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InitializerExpressionContext {
        rule_index: 157,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InitializerExpressionContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InitializerExpressionContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InitializerExpressionContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InitializerExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated InitializerExpressionContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated InitializerExpressionContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AwaitExpressionContext {
        rule_index: 158,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> AwaitExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AwaitExpressionContext", "expression"))
    }
    pub fn kw_await_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AwaitExpressionContext", "KW_AWAIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AwaitExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated AwaitExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_await_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 61).next() else {
            unreachable!("validated AwaitExpressionContext is missing required child KW_AWAIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseObjectCreationExpressionContext {
        rule_index: 159,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseObjectCreationExpressionContext<'a, State> {
    pub fn implicit_object_creation_expression(&self) -> Option<ImplicitObjectCreationExpressionContext<'a>> {
        __rule_children(self.__node, 160)
            .next()
            .map(|node| ImplicitObjectCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn object_creation_expression(&self) -> Option<ObjectCreationExpressionContext<'a>> {
        __rule_children(self.__node, 161)
            .next()
            .map(|node| ObjectCreationExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseObjectCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn implicit_object_creation_expression(&self) -> Option<ImplicitObjectCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 160)
            .next()
            .map(|node| ImplicitObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn object_creation_expression(&self) -> Option<ObjectCreationExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 161)
            .next()
            .map(|node| ObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ImplicitObjectCreationExpressionContext {
        rule_index: 160,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ImplicitObjectCreationExpressionContext<'a, State> {
    pub fn argument_list(&self) -> Result<ArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ImplicitObjectCreationExpressionContext", "argument_list"))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitObjectCreationExpressionContext", "KW_NEW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ImplicitObjectCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn argument_list(&self) -> ArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 31).next() else {
            unreachable!("validated ImplicitObjectCreationExpressionContext is missing required child argument_list")
        };
        ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated ImplicitObjectCreationExpressionContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ObjectCreationExpressionContext {
        rule_index: 161,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ObjectCreationExpressionContext<'a, State> {
    pub fn argument_list(&self) -> Option<ArgumentListContext<'a>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ObjectCreationExpressionContext", "type"))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ObjectCreationExpressionContext", "KW_NEW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ObjectCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn argument_list(&self) -> Option<ArgumentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated ObjectCreationExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated ObjectCreationExpressionContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CastExpressionContext {
        rule_index: 162,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CastExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CastExpressionContext", "type"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CastExpressionContext", "expression"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CastExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CastExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CastExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated CastExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated CastExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated CastExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated CastExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CheckedExpressionContext {
        rule_index: 163,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CheckedExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CheckedExpressionContext", "expression"))
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CheckedExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CheckedExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CheckedExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated CheckedExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated CheckedExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated CheckedExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CollectionExpressionContext {
        rule_index: 164,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CollectionExpressionContext<'a, State> {
    pub fn collection_element_children(&self) -> impl Iterator<Item = CollectionElementContext<'a>> + '_ {
        __rule_children(self.__node, 165)
            .map(move |node| CollectionElementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CollectionExpressionContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CollectionExpressionContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CollectionExpressionContext<'a, ValidatedTreeContext> {
    pub fn collection_element_children(&self) -> impl Iterator<Item = CollectionElementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 165)
            .map(move |node| CollectionElementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated CollectionExpressionContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated CollectionExpressionContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CollectionElementContext {
        rule_index: 165,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CollectionElementContext<'a, State> {
    pub fn expression_element(&self) -> Option<ExpressionElementContext<'a>> {
        __rule_children(self.__node, 166)
            .next()
            .map(|node| ExpressionElementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn spread_element(&self) -> Option<SpreadElementContext<'a>> {
        __rule_children(self.__node, 167)
            .next()
            .map(|node| SpreadElementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn with_element(&self) -> Option<WithElementContext<'a>> {
        __rule_children(self.__node, 168)
            .next()
            .map(|node| WithElementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CollectionElementContext<'a, ValidatedTreeContext> {
    pub fn expression_element(&self) -> Option<ExpressionElementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 166)
            .next()
            .map(|node| ExpressionElementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn spread_element(&self) -> Option<SpreadElementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 167)
            .next()
            .map(|node| SpreadElementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn with_element(&self) -> Option<WithElementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 168)
            .next()
            .map(|node| WithElementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionElementContext {
        rule_index: 166,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ExpressionElementContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExpressionElementContext", "expression"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionElementContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ExpressionElementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SpreadElementContext {
        rule_index: 167,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SpreadElementContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SpreadElementContext", "expression"))
    }
    pub fn dot_dot_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SpreadElementContext", "DOT_DOT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SpreadElementContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated SpreadElementContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn dot_dot_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 130).next() else {
            unreachable!("validated SpreadElementContext is missing required child DOT_DOT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct WithElementContext {
        rule_index: 168,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> WithElementContext<'a, State> {
    pub fn argument_list(&self) -> Result<ArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("WithElementContext", "argument_list"))
    }
    pub fn kw_with_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WithElementContext", "KW_WITH"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> WithElementContext<'a, ValidatedTreeContext> {
    pub fn argument_list(&self) -> ArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 31).next() else {
            unreachable!("validated WithElementContext is missing required child argument_list")
        };
        ArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_with_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 103).next() else {
            unreachable!("validated WithElementContext is missing required child KW_WITH")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DeclarationExpressionContext {
        rule_index: 169,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DeclarationExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DeclarationExpressionContext", "type"))
    }
    pub fn variable_designation(&self) -> Result<VariableDesignationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| VariableDesignationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DeclarationExpressionContext", "variable_designation"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DeclarationExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated DeclarationExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn variable_designation(&self) -> VariableDesignationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 117).next() else {
            unreachable!("validated DeclarationExpressionContext is missing required child variable_designation")
        };
        VariableDesignationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DefaultExpressionContext {
        rule_index: 170,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DefaultExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DefaultExpressionContext", "type"))
    }
    pub fn kw_default_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultExpressionContext", "KW_DEFAULT"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DefaultExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated DefaultExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_default_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 29).next() else {
            unreachable!("validated DefaultExpressionContext is missing required child KW_DEFAULT")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated DefaultExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated DefaultExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ElementBindingExpressionContext {
        rule_index: 171,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ElementBindingExpressionContext<'a, State> {
    pub fn bracketed_argument_list(&self) -> Result<BracketedArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ElementBindingExpressionContext", "bracketed_argument_list"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ElementBindingExpressionContext<'a, ValidatedTreeContext> {
    pub fn bracketed_argument_list(&self) -> BracketedArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 22).next() else {
            unreachable!("validated ElementBindingExpressionContext is missing required child bracketed_argument_list")
        };
        BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FieldExpressionContext {
        rule_index: 172,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FieldExpressionContext<'a, State> {
    pub fn kw_field_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FieldExpressionContext", "KW_FIELD"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FieldExpressionContext<'a, ValidatedTreeContext> {
    pub fn kw_field_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 68).next() else {
            unreachable!("validated FieldExpressionContext is missing required child KW_FIELD")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ImplicitArrayCreationExpressionContext {
        rule_index: 173,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ImplicitArrayCreationExpressionContext<'a, State> {
    pub fn initializer_expression(&self) -> Result<InitializerExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ImplicitArrayCreationExpressionContext", "initializer_expression"))
    }
    pub fn kw_new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitArrayCreationExpressionContext", "KW_NEW"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitArrayCreationExpressionContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitArrayCreationExpressionContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ImplicitArrayCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn initializer_expression(&self) -> InitializerExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 157).next() else {
            unreachable!("validated ImplicitArrayCreationExpressionContext is missing required child initializer_expression")
        };
        InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 113).next() else {
            unreachable!("validated ImplicitArrayCreationExpressionContext is missing required child KW_NEW")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated ImplicitArrayCreationExpressionContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated ImplicitArrayCreationExpressionContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ImplicitElementAccessContext {
        rule_index: 174,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ImplicitElementAccessContext<'a, State> {
    pub fn bracketed_argument_list(&self) -> Result<BracketedArgumentListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| BracketedArgumentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ImplicitElementAccessContext", "bracketed_argument_list"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ImplicitElementAccessContext<'a, ValidatedTreeContext> {
    pub fn bracketed_argument_list(&self) -> BracketedArgumentListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 22).next() else {
            unreachable!("validated ImplicitElementAccessContext is missing required child bracketed_argument_list")
        };
        BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ImplicitStackAllocArrayCreationExpressionContext {
        rule_index: 175,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ImplicitStackAllocArrayCreationExpressionContext<'a, State> {
    pub fn initializer_expression(&self) -> Result<InitializerExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ImplicitStackAllocArrayCreationExpressionContext", "initializer_expression"))
    }
    pub fn kw_stackalloc_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitStackAllocArrayCreationExpressionContext", "KW_STACKALLOC"))
    }
    pub fn lbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitStackAllocArrayCreationExpressionContext", "LBRACKET"))
    }
    pub fn rbracket_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImplicitStackAllocArrayCreationExpressionContext", "RBRACKET"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ImplicitStackAllocArrayCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn initializer_expression(&self) -> InitializerExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 157).next() else {
            unreachable!("validated ImplicitStackAllocArrayCreationExpressionContext is missing required child initializer_expression")
        };
        InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_stackalloc_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 5).next() else {
            unreachable!("validated ImplicitStackAllocArrayCreationExpressionContext is missing required child KW_STACKALLOC")
        };
        TerminalNode::new(node)
    }
    pub fn lbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 202).next() else {
            unreachable!("validated ImplicitStackAllocArrayCreationExpressionContext is missing required child LBRACKET")
        };
        TerminalNode::new(node)
    }
    pub fn rbracket_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 203).next() else {
            unreachable!("validated ImplicitStackAllocArrayCreationExpressionContext is missing required child RBRACKET")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InstanceExpressionContext {
        rule_index: 176,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InstanceExpressionContext<'a, State> {
    pub fn base_expression(&self) -> Option<BaseExpressionContext<'a>> {
        __rule_children(self.__node, 177)
            .next()
            .map(|node| BaseExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn this_expression(&self) -> Option<ThisExpressionContext<'a>> {
        __rule_children(self.__node, 178)
            .next()
            .map(|node| ThisExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InstanceExpressionContext<'a, ValidatedTreeContext> {
    pub fn base_expression(&self) -> Option<BaseExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 177)
            .next()
            .map(|node| BaseExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn this_expression(&self) -> Option<ThisExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 178)
            .next()
            .map(|node| ThisExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BaseExpressionContext {
        rule_index: 177,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> BaseExpressionContext<'a, State> {
    pub fn kw_base_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BaseExpressionContext", "KW_BASE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BaseExpressionContext<'a, ValidatedTreeContext> {
    pub fn kw_base_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 81).next() else {
            unreachable!("validated BaseExpressionContext is missing required child KW_BASE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ThisExpressionContext {
        rule_index: 178,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ThisExpressionContext<'a, State> {
    pub fn kw_this_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ThisExpressionContext", "KW_THIS"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ThisExpressionContext<'a, ValidatedTreeContext> {
    pub fn kw_this_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 98).next() else {
            unreachable!("validated ThisExpressionContext is missing required child KW_THIS")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedStringExpressionContext {
        rule_index: 179,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedStringExpressionContext<'a, State> {
    pub fn interpolated_string_content_children(&self) -> impl Iterator<Item = InterpolatedStringContentContext<'a>> + '_ {
        __rule_children(self.__node, 180)
            .map(move |node| InterpolatedStringContentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_multi_line_raw_string_start_token(&self) -> Option<InterpolatedMultiLineRawStringStartTokenContext<'a>> {
        __rule_children(self.__node, 185)
            .next()
            .map(|node| InterpolatedMultiLineRawStringStartTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_raw_string_end_token(&self) -> Option<InterpolatedRawStringEndTokenContext<'a>> {
        __rule_children(self.__node, 186)
            .next()
            .map(|node| InterpolatedRawStringEndTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_single_line_raw_string_start_token(&self) -> Option<InterpolatedSingleLineRawStringStartTokenContext<'a>> {
        __rule_children(self.__node, 187)
            .next()
            .map(|node| InterpolatedSingleLineRawStringStartTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dquote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 157)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interp_start_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 194)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interp_verbatim_start_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 195)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedStringExpressionContext<'a, ValidatedTreeContext> {
    pub fn interpolated_string_content_children(&self) -> impl Iterator<Item = InterpolatedStringContentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 180)
            .map(move |node| InterpolatedStringContentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_multi_line_raw_string_start_token(&self) -> Option<InterpolatedMultiLineRawStringStartTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 185)
            .next()
            .map(|node| InterpolatedMultiLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_raw_string_end_token(&self) -> Option<InterpolatedRawStringEndTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 186)
            .next()
            .map(|node| InterpolatedRawStringEndTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolated_single_line_raw_string_start_token(&self) -> Option<InterpolatedSingleLineRawStringStartTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 187)
            .next()
            .map(|node| InterpolatedSingleLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dquote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 157)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interp_start_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 194)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interp_verbatim_start_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 195)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedStringContentContext {
        rule_index: 180,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedStringContentContext<'a, State> {
    pub fn interpolated_string_text(&self) -> Option<InterpolatedStringTextContext<'a>> {
        __rule_children(self.__node, 181)
            .next()
            .map(|node| InterpolatedStringTextContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolation(&self) -> Option<InterpolationContext<'a>> {
        __rule_children(self.__node, 182)
            .next()
            .map(|node| InterpolationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedStringContentContext<'a, ValidatedTreeContext> {
    pub fn interpolated_string_text(&self) -> Option<InterpolatedStringTextContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 181)
            .next()
            .map(|node| InterpolatedStringTextContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolation(&self) -> Option<InterpolationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 182)
            .next()
            .map(|node| InterpolationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedStringTextContext {
        rule_index: 181,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedStringTextContext<'a, State> {
    pub fn interpolated_string_text_token(&self) -> Result<InterpolatedStringTextTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 234)
            .next()
            .map(|node| InterpolatedStringTextTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterpolatedStringTextContext", "interpolated_string_text_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedStringTextContext<'a, ValidatedTreeContext> {
    pub fn interpolated_string_text_token(&self) -> InterpolatedStringTextTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 234).next() else {
            unreachable!("validated InterpolatedStringTextContext is missing required child interpolated_string_text_token")
        };
        InterpolatedStringTextTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolationContext {
        rule_index: 182,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolationContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterpolationContext", "expression"))
    }
    pub fn interpolation_alignment_clause(&self) -> Option<InterpolationAlignmentClauseContext<'a>> {
        __rule_children(self.__node, 183)
            .next()
            .map(|node| InterpolationAlignmentClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolation_format_clause(&self) -> Option<InterpolationFormatClauseContext<'a>> {
        __rule_children(self.__node, 184)
            .next()
            .map(|node| InterpolationFormatClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolationContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolationContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolationContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated InterpolationContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn interpolation_alignment_clause(&self) -> Option<InterpolationAlignmentClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 183)
            .next()
            .map(|node| InterpolationAlignmentClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interpolation_format_clause(&self) -> Option<InterpolationFormatClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 184)
            .next()
            .map(|node| InterpolationFormatClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 197).next() else {
            unreachable!("validated InterpolationContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 198).next() else {
            unreachable!("validated InterpolationContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolationAlignmentClauseContext {
        rule_index: 183,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolationAlignmentClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterpolationAlignmentClauseContext", "expression"))
    }
    pub fn comma_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 163)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolationAlignmentClauseContext", "COMMA"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolationAlignmentClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated InterpolationAlignmentClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn comma_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 163).next() else {
            unreachable!("validated InterpolationAlignmentClauseContext is missing required child COMMA")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolationFormatClauseContext {
        rule_index: 184,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolationFormatClauseContext<'a, State> {
    pub fn interpolated_string_text_token(&self) -> Result<InterpolatedStringTextTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 234)
            .next()
            .map(|node| InterpolatedStringTextTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterpolationFormatClauseContext", "interpolated_string_text_token"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolationFormatClauseContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolationFormatClauseContext<'a, ValidatedTreeContext> {
    pub fn interpolated_string_text_token(&self) -> InterpolatedStringTextTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 234).next() else {
            unreachable!("validated InterpolationFormatClauseContext is missing required child interpolated_string_text_token")
        };
        InterpolatedStringTextTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 199).next() else {
            unreachable!("validated InterpolationFormatClauseContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedMultiLineRawStringStartTokenContext {
        rule_index: 185,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedMultiLineRawStringStartTokenContext<'a, State> {
    pub fn interp_raw_start_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 196)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolatedMultiLineRawStringStartTokenContext", "INTERP_RAW_START"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedMultiLineRawStringStartTokenContext<'a, ValidatedTreeContext> {
    pub fn interp_raw_start_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 196).next() else {
            unreachable!("validated InterpolatedMultiLineRawStringStartTokenContext is missing required child INTERP_RAW_START")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedRawStringEndTokenContext {
        rule_index: 186,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedRawStringEndTokenContext<'a, State> {
    pub fn triple_dquote_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolatedRawStringEndTokenContext", "TRIPLE_DQUOTE"))
    }
    pub fn dquote_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 157).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedRawStringEndTokenContext<'a, ValidatedTreeContext> {
    pub fn triple_dquote_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 104).next() else {
            unreachable!("validated InterpolatedRawStringEndTokenContext is missing required child TRIPLE_DQUOTE")
        };
        TerminalNode::new(node)
    }
    pub fn dquote_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 157).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedSingleLineRawStringStartTokenContext {
        rule_index: 187,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedSingleLineRawStringStartTokenContext<'a, State> {
    pub fn interp_raw_start_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 196)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolatedSingleLineRawStringStartTokenContext", "INTERP_RAW_START"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedSingleLineRawStringStartTokenContext<'a, ValidatedTreeContext> {
    pub fn interp_raw_start_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 196).next() else {
            unreachable!("validated InterpolatedSingleLineRawStringStartTokenContext is missing required child INTERP_RAW_START")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LiteralExpressionContext {
        rule_index: 188,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LiteralExpressionContext<'a, State> {
    pub fn utf8_multi_line_raw_string_literal_token(&self) -> Option<Utf8MultiLineRawStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 189)
            .next()
            .map(|node| Utf8MultiLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn utf8_single_line_raw_string_literal_token(&self) -> Option<Utf8SingleLineRawStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 190)
            .next()
            .map(|node| Utf8SingleLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn utf8_string_literal_token(&self) -> Option<Utf8StringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 191)
            .next()
            .map(|node| Utf8StringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn numeric_literal_token(&self) -> Option<NumericLiteralTokenContext<'a>> {
        __rule_children(self.__node, 223)
            .next()
            .map(|node| NumericLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn character_literal_token(&self) -> Option<CharacterLiteralTokenContext<'a>> {
        __rule_children(self.__node, 228)
            .next()
            .map(|node| CharacterLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn string_literal_token(&self) -> Option<StringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 229)
            .next()
            .map(|node| StringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn multi_line_raw_string_literal_token(&self) -> Option<MultiLineRawStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 235)
            .next()
            .map(|node| MultiLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn single_line_raw_string_literal_token(&self) -> Option<SingleLineRawStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 236)
            .next()
            .map(|node| SingleLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_null_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LiteralExpressionContext<'a, ValidatedTreeContext> {
    pub fn utf8_multi_line_raw_string_literal_token(&self) -> Option<Utf8MultiLineRawStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 189)
            .next()
            .map(|node| Utf8MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn utf8_single_line_raw_string_literal_token(&self) -> Option<Utf8SingleLineRawStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 190)
            .next()
            .map(|node| Utf8SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn utf8_string_literal_token(&self) -> Option<Utf8StringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 191)
            .next()
            .map(|node| Utf8StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn numeric_literal_token(&self) -> Option<NumericLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 223)
            .next()
            .map(|node| NumericLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn character_literal_token(&self) -> Option<CharacterLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 228)
            .next()
            .map(|node| CharacterLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn string_literal_token(&self) -> Option<StringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 229)
            .next()
            .map(|node| StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn multi_line_raw_string_literal_token(&self) -> Option<MultiLineRawStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 235)
            .next()
            .map(|node| MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn single_line_raw_string_literal_token(&self) -> Option<SingleLineRawStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 236)
            .next()
            .map(|node| SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_null_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct Utf8MultiLineRawStringLiteralTokenContext {
        rule_index: 189,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> Utf8MultiLineRawStringLiteralTokenContext<'a, State> {
    pub fn multi_line_raw_string_literal_token(&self) -> Result<MultiLineRawStringLiteralTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 235)
            .next()
            .map(|node| MultiLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("Utf8MultiLineRawStringLiteralTokenContext", "multi_line_raw_string_literal_token"))
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> Utf8MultiLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn multi_line_raw_string_literal_token(&self) -> MultiLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 235).next() else {
            unreachable!("validated Utf8MultiLineRawStringLiteralTokenContext is missing required child multi_line_raw_string_literal_token")
        };
        MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct Utf8SingleLineRawStringLiteralTokenContext {
        rule_index: 190,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> Utf8SingleLineRawStringLiteralTokenContext<'a, State> {
    pub fn single_line_raw_string_literal_token(&self) -> Result<SingleLineRawStringLiteralTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 236)
            .next()
            .map(|node| SingleLineRawStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("Utf8SingleLineRawStringLiteralTokenContext", "single_line_raw_string_literal_token"))
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> Utf8SingleLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn single_line_raw_string_literal_token(&self) -> SingleLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 236).next() else {
            unreachable!("validated Utf8SingleLineRawStringLiteralTokenContext is missing required child single_line_raw_string_literal_token")
        };
        SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct Utf8StringLiteralTokenContext {
        rule_index: 191,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> Utf8StringLiteralTokenContext<'a, State> {
    pub fn string_literal_token(&self) -> Result<StringLiteralTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 229)
            .next()
            .map(|node| StringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("Utf8StringLiteralTokenContext", "string_literal_token"))
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> Utf8StringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn string_literal_token(&self) -> StringLiteralTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 229).next() else {
            unreachable!("validated Utf8StringLiteralTokenContext is missing required child string_literal_token")
        };
        StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MakeRefExpressionContext {
        rule_index: 192,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> MakeRefExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MakeRefExpressionContext", "expression"))
    }
    pub fn kw_makeref_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 7)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MakeRefExpressionContext", "KW___MAKEREF"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MakeRefExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MakeRefExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MakeRefExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated MakeRefExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_makeref_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 7).next() else {
            unreachable!("validated MakeRefExpressionContext is missing required child KW___MAKEREF")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated MakeRefExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated MakeRefExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MemberBindingExpressionContext {
        rule_index: 193,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> MemberBindingExpressionContext<'a, State> {
    pub fn simple_name(&self) -> Result<SimpleNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 10)
            .next()
            .map(|node| SimpleNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MemberBindingExpressionContext", "simple_name"))
    }
    pub fn dot_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MemberBindingExpressionContext", "DOT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MemberBindingExpressionContext<'a, ValidatedTreeContext> {
    pub fn simple_name(&self) -> SimpleNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 10).next() else {
            unreachable!("validated MemberBindingExpressionContext is missing required child simple_name")
        };
        SimpleNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn dot_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 165).next() else {
            unreachable!("validated MemberBindingExpressionContext is missing required child DOT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ParenthesizedExpressionContext {
        rule_index: 194,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ParenthesizedExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ParenthesizedExpressionContext", "expression"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ParenthesizedExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ParenthesizedExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ParenthesizedExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated ParenthesizedExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated ParenthesizedExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PrefixUnaryExpressionContext {
        rule_index: 195,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PrefixUnaryExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PrefixUnaryExpressionContext", "expression"))
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PrefixUnaryExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated PrefixUnaryExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QueryExpressionContext {
        rule_index: 196,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> QueryExpressionContext<'a, State> {
    pub fn from_clause(&self) -> Result<FromClauseContext<'a>, MissingChildError> {
        __rule_children(self.__node, 197)
            .next()
            .map(|node| FromClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("QueryExpressionContext", "from_clause"))
    }
    pub fn query_body(&self) -> Result<QueryBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 198)
            .next()
            .map(|node| QueryBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("QueryExpressionContext", "query_body"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QueryExpressionContext<'a, ValidatedTreeContext> {
    pub fn from_clause(&self) -> FromClauseContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 197).next() else {
            unreachable!("validated QueryExpressionContext is missing required child from_clause")
        };
        FromClauseContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn query_body(&self) -> QueryBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 198).next() else {
            unreachable!("validated QueryExpressionContext is missing required child query_body")
        };
        QueryBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FromClauseContext {
        rule_index: 197,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> FromClauseContext<'a, State> {
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FromClauseContext", "expression"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FromClauseContext", "identifier_token"))
    }
    pub fn kw_from_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FromClauseContext", "KW_FROM"))
    }
    pub fn kw_in_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FromClauseContext", "KW_IN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FromClauseContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated FromClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated FromClauseContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_from_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 89).next() else {
            unreachable!("validated FromClauseContext is missing required child KW_FROM")
        };
        TerminalNode::new(node)
    }
    pub fn kw_in_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 149).next() else {
            unreachable!("validated FromClauseContext is missing required child KW_IN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QueryBodyContext {
        rule_index: 198,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> QueryBodyContext<'a, State> {
    pub fn query_clause_children(&self) -> impl Iterator<Item = QueryClauseContext<'a>> + '_ {
        __rule_children(self.__node, 199)
            .map(move |node| QueryClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn select_or_group_clause(&self) -> Result<SelectOrGroupClauseContext<'a>, MissingChildError> {
        __rule_children(self.__node, 206)
            .next()
            .map(|node| SelectOrGroupClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("QueryBodyContext", "select_or_group_clause"))
    }
    pub fn query_continuation(&self) -> Option<QueryContinuationContext<'a>> {
        __rule_children(self.__node, 209)
            .next()
            .map(|node| QueryContinuationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QueryBodyContext<'a, ValidatedTreeContext> {
    pub fn query_clause_children(&self) -> impl Iterator<Item = QueryClauseContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 199)
            .map(move |node| QueryClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn select_or_group_clause(&self) -> SelectOrGroupClauseContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 206).next() else {
            unreachable!("validated QueryBodyContext is missing required child select_or_group_clause")
        };
        SelectOrGroupClauseContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn query_continuation(&self) -> Option<QueryContinuationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 209)
            .next()
            .map(|node| QueryContinuationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QueryClauseContext {
        rule_index: 199,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> QueryClauseContext<'a, State> {
    pub fn from_clause(&self) -> Option<FromClauseContext<'a>> {
        __rule_children(self.__node, 197)
            .next()
            .map(|node| FromClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn join_clause(&self) -> Option<JoinClauseContext<'a>> {
        __rule_children(self.__node, 200)
            .next()
            .map(|node| JoinClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn let_clause(&self) -> Option<LetClauseContext<'a>> {
        __rule_children(self.__node, 202)
            .next()
            .map(|node| LetClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn order_by_clause(&self) -> Option<OrderByClauseContext<'a>> {
        __rule_children(self.__node, 203)
            .next()
            .map(|node| OrderByClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn where_clause(&self) -> Option<WhereClauseContext<'a>> {
        __rule_children(self.__node, 205)
            .next()
            .map(|node| WhereClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QueryClauseContext<'a, ValidatedTreeContext> {
    pub fn from_clause(&self) -> Option<FromClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 197)
            .next()
            .map(|node| FromClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn join_clause(&self) -> Option<JoinClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 200)
            .next()
            .map(|node| JoinClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn let_clause(&self) -> Option<LetClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 202)
            .next()
            .map(|node| LetClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn order_by_clause(&self) -> Option<OrderByClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 203)
            .next()
            .map(|node| OrderByClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn where_clause(&self) -> Option<WhereClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 205)
            .next()
            .map(|node| WhereClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct JoinClauseContext {
        rule_index: 200,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> JoinClauseContext<'a, State> {
    pub fn r#type(&self) -> Option<TypeContext<'a>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn join_into_clause(&self) -> Option<JoinIntoClauseContext<'a>> {
        __rule_children(self.__node, 201)
            .next()
            .map(|node| JoinIntoClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("JoinClauseContext", "identifier_token"))
    }
    pub fn kw_equals_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("JoinClauseContext", "KW_EQUALS"))
    }
    pub fn kw_join_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("JoinClauseContext", "KW_JOIN"))
    }
    pub fn kw_in_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("JoinClauseContext", "KW_IN"))
    }
    pub fn kw_on_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 151)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("JoinClauseContext", "KW_ON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> JoinClauseContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> Option<TypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn join_into_clause(&self) -> Option<JoinIntoClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 201)
            .next()
            .map(|node| JoinIntoClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated JoinClauseContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_equals_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 40).next() else {
            unreachable!("validated JoinClauseContext is missing required child KW_EQUALS")
        };
        TerminalNode::new(node)
    }
    pub fn kw_join_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 93).next() else {
            unreachable!("validated JoinClauseContext is missing required child KW_JOIN")
        };
        TerminalNode::new(node)
    }
    pub fn kw_in_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 149).next() else {
            unreachable!("validated JoinClauseContext is missing required child KW_IN")
        };
        TerminalNode::new(node)
    }
    pub fn kw_on_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 151).next() else {
            unreachable!("validated JoinClauseContext is missing required child KW_ON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct JoinIntoClauseContext {
        rule_index: 201,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> JoinIntoClauseContext<'a, State> {
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("JoinIntoClauseContext", "identifier_token"))
    }
    pub fn kw_into_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("JoinIntoClauseContext", "KW_INTO"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> JoinIntoClauseContext<'a, ValidatedTreeContext> {
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated JoinIntoClauseContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_into_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 92).next() else {
            unreachable!("validated JoinIntoClauseContext is missing required child KW_INTO")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LetClauseContext {
        rule_index: 202,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LetClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LetClauseContext", "expression"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LetClauseContext", "identifier_token"))
    }
    pub fn kw_let_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LetClauseContext", "KW_LET"))
    }
    pub fn eq_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LetClauseContext", "EQ"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LetClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated LetClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated LetClauseContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_let_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 112).next() else {
            unreachable!("validated LetClauseContext is missing required child KW_LET")
        };
        TerminalNode::new(node)
    }
    pub fn eq_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 169).next() else {
            unreachable!("validated LetClauseContext is missing required child EQ")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct OrderByClauseContext {
        rule_index: 203,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> OrderByClauseContext<'a, State> {
    pub fn ordering_children(&self) -> impl Iterator<Item = OrderingContext<'a>> + '_ {
        __rule_children(self.__node, 204)
            .map(move |node| OrderingContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_orderby_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("OrderByClauseContext", "KW_ORDERBY"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> OrderByClauseContext<'a, ValidatedTreeContext> {
    pub fn ordering_children(&self) -> impl Iterator<Item = OrderingContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 204)
            .map(move |node| OrderingContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_orderby_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 33).next() else {
            unreachable!("validated OrderByClauseContext is missing required child KW_ORDERBY")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct OrderingContext {
        rule_index: 204,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> OrderingContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("OrderingContext", "expression"))
    }
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> OrderingContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated OrderingContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct WhereClauseContext {
        rule_index: 205,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> WhereClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("WhereClauseContext", "expression"))
    }
    pub fn kw_where_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("WhereClauseContext", "KW_WHERE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> WhereClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated WhereClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_where_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 78).next() else {
            unreachable!("validated WhereClauseContext is missing required child KW_WHERE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SelectOrGroupClauseContext {
        rule_index: 206,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SelectOrGroupClauseContext<'a, State> {
    pub fn group_clause(&self) -> Option<GroupClauseContext<'a>> {
        __rule_children(self.__node, 207)
            .next()
            .map(|node| GroupClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn select_clause(&self) -> Option<SelectClauseContext<'a>> {
        __rule_children(self.__node, 208)
            .next()
            .map(|node| SelectClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SelectOrGroupClauseContext<'a, ValidatedTreeContext> {
    pub fn group_clause(&self) -> Option<GroupClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 207)
            .next()
            .map(|node| GroupClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn select_clause(&self) -> Option<SelectClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 208)
            .next()
            .map(|node| SelectClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GroupClauseContext {
        rule_index: 207,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> GroupClauseContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_group_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("GroupClauseContext", "KW_GROUP"))
    }
    pub fn kw_by_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 146)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("GroupClauseContext", "KW_BY"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GroupClauseContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 148)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_group_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 71).next() else {
            unreachable!("validated GroupClauseContext is missing required child KW_GROUP")
        };
        TerminalNode::new(node)
    }
    pub fn kw_by_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 146).next() else {
            unreachable!("validated GroupClauseContext is missing required child KW_BY")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SelectClauseContext {
        rule_index: 208,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SelectClauseContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SelectClauseContext", "expression"))
    }
    pub fn kw_select_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SelectClauseContext", "KW_SELECT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SelectClauseContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated SelectClauseContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_select_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 50).next() else {
            unreachable!("validated SelectClauseContext is missing required child KW_SELECT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QueryContinuationContext {
        rule_index: 209,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> QueryContinuationContext<'a, State> {
    pub fn query_body(&self) -> Result<QueryBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 198)
            .next()
            .map(|node| QueryBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("QueryContinuationContext", "query_body"))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("QueryContinuationContext", "identifier_token"))
    }
    pub fn kw_into_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("QueryContinuationContext", "KW_INTO"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QueryContinuationContext<'a, ValidatedTreeContext> {
    pub fn query_body(&self) -> QueryBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 198).next() else {
            unreachable!("validated QueryContinuationContext is missing required child query_body")
        };
        QueryBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated QueryContinuationContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_into_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 92).next() else {
            unreachable!("validated QueryContinuationContext is missing required child KW_INTO")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RefExpressionContext {
        rule_index: 210,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RefExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RefExpressionContext", "expression"))
    }
    pub fn kw_ref_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefExpressionContext", "KW_REF"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RefExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated RefExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_ref_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 116).next() else {
            unreachable!("validated RefExpressionContext is missing required child KW_REF")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RefTypeExpressionContext {
        rule_index: 211,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RefTypeExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RefTypeExpressionContext", "expression"))
    }
    pub fn kw_reftype_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 8)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefTypeExpressionContext", "KW___REFTYPE"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefTypeExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefTypeExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RefTypeExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated RefTypeExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_reftype_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 8).next() else {
            unreachable!("validated RefTypeExpressionContext is missing required child KW___REFTYPE")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated RefTypeExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated RefTypeExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RefValueExpressionContext {
        rule_index: 212,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RefValueExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "type"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "expression"))
    }
    pub fn kw_refvalue_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 3)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "KW___REFVALUE"))
    }
    pub fn comma_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 163)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "COMMA"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RefValueExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RefValueExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_refvalue_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 3).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child KW___REFVALUE")
        };
        TerminalNode::new(node)
    }
    pub fn comma_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 163).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child COMMA")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated RefValueExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SizeOfExpressionContext {
        rule_index: 213,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SizeOfExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SizeOfExpressionContext", "type"))
    }
    pub fn kw_sizeof_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SizeOfExpressionContext", "KW_SIZEOF"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SizeOfExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SizeOfExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SizeOfExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated SizeOfExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_sizeof_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 51).next() else {
            unreachable!("validated SizeOfExpressionContext is missing required child KW_SIZEOF")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated SizeOfExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated SizeOfExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct StackAllocArrayCreationExpressionContext {
        rule_index: 214,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> StackAllocArrayCreationExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("StackAllocArrayCreationExpressionContext", "type"))
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_stackalloc_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("StackAllocArrayCreationExpressionContext", "KW_STACKALLOC"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> StackAllocArrayCreationExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated StackAllocArrayCreationExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn initializer_expression(&self) -> Option<InitializerExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 157)
            .next()
            .map(|node| InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_stackalloc_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 5).next() else {
            unreachable!("validated StackAllocArrayCreationExpressionContext is missing required child KW_STACKALLOC")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchExpressionArmContext {
        rule_index: 215,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SwitchExpressionArmContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SwitchExpressionArmContext", "pattern"))
    }
    pub fn when_clause(&self) -> Option<WhenClauseContext<'a>> {
        __rule_children(self.__node, 135)
            .next()
            .map(|node| WhenClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SwitchExpressionArmContext", "expression"))
    }
    pub fn arrow_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionArmContext", "ARROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchExpressionArmContext<'a, ValidatedTreeContext> {
    pub fn pattern(&self) -> PatternContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 114).next() else {
            unreachable!("validated SwitchExpressionArmContext is missing required child pattern")
        };
        PatternContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn when_clause(&self) -> Option<WhenClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 135)
            .next()
            .map(|node| WhenClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated SwitchExpressionArmContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn arrow_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 138).next() else {
            unreachable!("validated SwitchExpressionArmContext is missing required child ARROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ThrowExpressionContext {
        rule_index: 216,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> ThrowExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ThrowExpressionContext", "expression"))
    }
    pub fn kw_throw_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ThrowExpressionContext", "KW_THROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ThrowExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated ThrowExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_throw_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 74).next() else {
            unreachable!("validated ThrowExpressionContext is missing required child KW_THROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TupleExpressionContext {
        rule_index: 217,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TupleExpressionContext<'a, State> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TupleExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TupleExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TupleExpressionContext<'a, ValidatedTreeContext> {
    pub fn argument_children(&self) -> impl Iterator<Item = ArgumentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 23)
            .map(move |node| ArgumentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated TupleExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated TupleExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeOfExpressionContext {
        rule_index: 218,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> TypeOfExpressionContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypeOfExpressionContext", "type"))
    }
    pub fn kw_typeof_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeOfExpressionContext", "KW_TYPEOF"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeOfExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeOfExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeOfExpressionContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated TypeOfExpressionContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_typeof_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 56).next() else {
            unreachable!("validated TypeOfExpressionContext is missing required child KW_TYPEOF")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated TypeOfExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated TypeOfExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnsafeExpressionContext {
        rule_index: 219,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnsafeExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 148)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UnsafeExpressionContext", "expression"))
    }
    pub fn kw_unsafe_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnsafeExpressionContext", "KW_UNSAFE"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnsafeExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnsafeExpressionContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnsafeExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 148).next() else {
            unreachable!("validated UnsafeExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn kw_unsafe_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 57).next() else {
            unreachable!("validated UnsafeExpressionContext is missing required child KW_UNSAFE")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 200).next() else {
            unreachable!("validated UnsafeExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 201).next() else {
            unreachable!("validated UnsafeExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SyntaxTokenContext {
        rule_index: 220,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SyntaxTokenContext<'a, State> {
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn keyword(&self) -> Option<KeywordContext<'a>> {
        __rule_children(self.__node, 222)
            .next()
            .map(|node| KeywordContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn numeric_literal_token(&self) -> Option<NumericLiteralTokenContext<'a>> {
        __rule_children(self.__node, 223)
            .next()
            .map(|node| NumericLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn character_literal_token(&self) -> Option<CharacterLiteralTokenContext<'a>> {
        __rule_children(self.__node, 228)
            .next()
            .map(|node| CharacterLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn string_literal_token(&self) -> Option<StringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 229)
            .next()
            .map(|node| StringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn operator_token(&self) -> Option<OperatorTokenContext<'a>> {
        __rule_children(self.__node, 232)
            .next()
            .map(|node| OperatorTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn punctuation_token(&self) -> Option<PunctuationTokenContext<'a>> {
        __rule_children(self.__node, 233)
            .next()
            .map(|node| PunctuationTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SyntaxTokenContext<'a, ValidatedTreeContext> {
    pub fn identifier_token(&self) -> Option<IdentifierTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn keyword(&self) -> Option<KeywordContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 222)
            .next()
            .map(|node| KeywordContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn numeric_literal_token(&self) -> Option<NumericLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 223)
            .next()
            .map(|node| NumericLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn character_literal_token(&self) -> Option<CharacterLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 228)
            .next()
            .map(|node| CharacterLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn string_literal_token(&self) -> Option<StringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 229)
            .next()
            .map(|node| StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn operator_token(&self) -> Option<OperatorTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 232)
            .next()
            .map(|node| OperatorTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn punctuation_token(&self) -> Option<PunctuationTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 233)
            .next()
            .map(|node| PunctuationTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IdentifierTokenContext {
        rule_index: 221,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> IdentifierTokenContext<'a, State> {
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extension_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 10)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_orderby_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_allows_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_equals_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_select_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_alias_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_field_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_group_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_union_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_where_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_from_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_into_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_join_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_let_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_not_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_by_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 146)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_on_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 151)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 152)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 176)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 177)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IdentifierTokenContext<'a, ValidatedTreeContext> {
    pub fn kw_descending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ascending_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_extension_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 10)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unmanaged_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_required_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_managed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_orderby_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_partial_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_allows_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_closed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_equals_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_global_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_remove_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_scoped_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_select_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_alias_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_async_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_await_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_field_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_group_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_union_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_where_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_file_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_from_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_init_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_into_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_join_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_safe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_get_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_let_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_not_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_set_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 141)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_by_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 146)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_on_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 151)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 152)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_u8_lower_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 153)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 173)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 176)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 177)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct KeywordContext {
        rule_index: 222,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> KeywordContext<'a, State> {
    pub fn modifier(&self) -> Option<ModifierContext<'a>> {
        __rule_children(self.__node, 19)
            .next()
            .map(|node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_refvalue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 3)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_stackalloc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_makeref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 7)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_reftype_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 8)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_interface_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 11)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_namespace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_continue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_delegate_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_explicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_implicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 20)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_operator_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_decimal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_finally_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 30)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_foreach_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_object_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_params_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sizeof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_string_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_typeof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ushort_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_catch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 63)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_event_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sbyte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_throw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ulong_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_while_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_base_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_bool_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_else_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 86)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_enum_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_goto_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_lock_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_null_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_uint_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_for_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_try_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_do_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 147)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_if_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 148)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> KeywordContext<'a, ValidatedTreeContext> {
    pub fn modifier(&self) -> Option<ModifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 19)
            .next()
            .map(|node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn kw_refvalue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 3)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_stackalloc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_arglist_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_makeref_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 7)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_reftype_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 8)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_interface_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 11)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_namespace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_unchecked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_continue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_delegate_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_explicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_implicit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 20)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_operator_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_checked_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_decimal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_finally_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 30)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_foreach_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_object_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_params_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sizeof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_string_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_struct_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_typeof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ushort_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_catch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 63)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_event_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_false_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_sbyte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_throw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_ulong_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_using_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_while_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_base_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_bool_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_else_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 86)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_enum_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_goto_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_lock_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_null_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_true_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_uint_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_for_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_out_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_try_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_do_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 147)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_if_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 148)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_in_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 149)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NumericLiteralTokenContext {
        rule_index: 223,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> NumericLiteralTokenContext<'a, State> {
    pub fn integer_literal_token(&self) -> Option<IntegerLiteralTokenContext<'a>> {
        __rule_children(self.__node, 224)
            .next()
            .map(|node| IntegerLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn real_literal_token(&self) -> Option<RealLiteralTokenContext<'a>> {
        __rule_children(self.__node, 227)
            .next()
            .map(|node| RealLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NumericLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn integer_literal_token(&self) -> Option<IntegerLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 224)
            .next()
            .map(|node| IntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn real_literal_token(&self) -> Option<RealLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 227)
            .next()
            .map(|node| RealLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IntegerLiteralTokenContext {
        rule_index: 224,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> IntegerLiteralTokenContext<'a, State> {
    pub fn decimal_integer_literal_token(&self) -> Option<DecimalIntegerLiteralTokenContext<'a>> {
        __rule_children(self.__node, 225)
            .next()
            .map(|node| DecimalIntegerLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn hexadecimal_integer_literal_token(&self) -> Option<HexadecimalIntegerLiteralTokenContext<'a>> {
        __rule_children(self.__node, 226)
            .next()
            .map(|node| HexadecimalIntegerLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bin_int_lit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 180)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IntegerLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn decimal_integer_literal_token(&self) -> Option<DecimalIntegerLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 225)
            .next()
            .map(|node| DecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn hexadecimal_integer_literal_token(&self) -> Option<HexadecimalIntegerLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 226)
            .next()
            .map(|node| HexadecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bin_int_lit_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 180)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct DecimalIntegerLiteralTokenContext {
        rule_index: 225,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> DecimalIntegerLiteralTokenContext<'a, State> {
    pub fn dec_int_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 178)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DecimalIntegerLiteralTokenContext", "DEC_INT_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DecimalIntegerLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn dec_int_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 178).next() else {
            unreachable!("validated DecimalIntegerLiteralTokenContext is missing required child DEC_INT_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct HexadecimalIntegerLiteralTokenContext {
        rule_index: 226,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> HexadecimalIntegerLiteralTokenContext<'a, State> {
    pub fn hex_int_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 179)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("HexadecimalIntegerLiteralTokenContext", "HEX_INT_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> HexadecimalIntegerLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn hex_int_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 179).next() else {
            unreachable!("validated HexadecimalIntegerLiteralTokenContext is missing required child HEX_INT_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RealLiteralTokenContext {
        rule_index: 227,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RealLiteralTokenContext<'a, State> {
    pub fn real_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 181)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RealLiteralTokenContext", "REAL_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RealLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn real_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 181).next() else {
            unreachable!("validated RealLiteralTokenContext is missing required child REAL_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CharacterLiteralTokenContext {
        rule_index: 228,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> CharacterLiteralTokenContext<'a, State> {
    pub fn char_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 182)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CharacterLiteralTokenContext", "CHAR_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CharacterLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn char_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 182).next() else {
            unreachable!("validated CharacterLiteralTokenContext is missing required child CHAR_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct StringLiteralTokenContext {
        rule_index: 229,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> StringLiteralTokenContext<'a, State> {
    pub fn regular_string_literal_token(&self) -> Option<RegularStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 230)
            .next()
            .map(|node| RegularStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn verbatim_string_literal_token(&self) -> Option<VerbatimStringLiteralTokenContext<'a>> {
        __rule_children(self.__node, 231)
            .next()
            .map(|node| VerbatimStringLiteralTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> StringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn regular_string_literal_token(&self) -> Option<RegularStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 230)
            .next()
            .map(|node| RegularStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn verbatim_string_literal_token(&self) -> Option<VerbatimStringLiteralTokenContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 231)
            .next()
            .map(|node| VerbatimStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RegularStringLiteralTokenContext {
        rule_index: 230,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RegularStringLiteralTokenContext<'a, State> {
    pub fn string_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 183)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RegularStringLiteralTokenContext", "STRING_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RegularStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn string_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 183).next() else {
            unreachable!("validated RegularStringLiteralTokenContext is missing required child STRING_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VerbatimStringLiteralTokenContext {
        rule_index: 231,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> VerbatimStringLiteralTokenContext<'a, State> {
    pub fn verbatim_string_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 184)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("VerbatimStringLiteralTokenContext", "VERBATIM_STRING_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VerbatimStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn verbatim_string_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 184).next() else {
            unreachable!("validated VerbatimStringLiteralTokenContext is missing required child VERBATIM_STRING_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct OperatorTokenContext {
        rule_index: 232,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> OperatorTokenContext<'a, State> {
    pub fn right_shift(&self) -> Option<RightShiftContext<'a>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 140)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 155)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> OperatorTokenContext<'a, ValidatedTreeContext> {
    pub fn right_shift(&self) -> Option<RightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 238)
            .next()
            .map(|node| RightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift(&self) -> Option<UnsignedRightShiftContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 239)
            .next()
            .map(|node| UnsignedRightShiftContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn right_shift_assignment(&self) -> Option<RightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 240)
            .next()
            .map(|node| RightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn unsigned_right_shift_assignment(&self) -> Option<UnsignedRightShiftAssignmentContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 241)
            .next()
            .map(|node| UnsignedRightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lt_lt_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ne_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 126)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 127)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 128)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 131)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 135)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 136)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 137)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 140)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 144)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_as_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 145)
            .next()
            .map(TerminalNode::new)
    }
    pub fn kw_is_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 150)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 154)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 155)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 156)
            .next()
            .map(TerminalNode::new)
    }
    pub fn percent_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 159)
            .next()
            .map(TerminalNode::new)
    }
    pub fn amp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 160)
            .next()
            .map(TerminalNode::new)
    }
    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 161)
            .next()
            .map(TerminalNode::new)
    }
    pub fn plus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 162)
            .next()
            .map(TerminalNode::new)
    }
    pub fn minus_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 164)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 166)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 168)
            .next()
            .map(TerminalNode::new)
    }
    pub fn eq_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 169)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 172)
            .next()
            .map(TerminalNode::new)
    }
    pub fn pipe_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 174)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 175)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PunctuationTokenContext {
        rule_index: 233,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> PunctuationTokenContext<'a, State> {
    pub fn minus_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 132)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 133)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 134)
            .next()
            .map(TerminalNode::new)
    }
    pub fn arrow_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
    }
    pub fn escaped_quote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 142)
            .next()
            .map(TerminalNode::new)
    }
    pub fn escaped_backslash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 143)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dquote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 157)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 158)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 163)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbracket_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PunctuationTokenContext<'a, ValidatedTreeContext> {
    pub fn minus_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 130)
            .next()
            .map(TerminalNode::new)
    }
    pub fn slash_gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 132)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 133)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_slash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 134)
            .next()
            .map(TerminalNode::new)
    }
    pub fn arrow_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 138)
            .next()
            .map(TerminalNode::new)
    }
    pub fn escaped_quote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 142)
            .next()
            .map(TerminalNode::new)
    }
    pub fn escaped_backslash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 143)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dquote_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 157)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hash_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 158)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 163)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 165)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semicolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 167)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 171)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 197)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 198)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 199)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 200)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 201)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbracket_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 202)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbracket_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 203)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterpolatedStringTextTokenContext {
        rule_index: 234,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> InterpolatedStringTextTokenContext<'a, State> {
    pub fn interpolated_text_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 1)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterpolatedStringTextTokenContext", "INTERPOLATED_TEXT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterpolatedStringTextTokenContext<'a, ValidatedTreeContext> {
    pub fn interpolated_text_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 1).next() else {
            unreachable!("validated InterpolatedStringTextTokenContext is missing required child INTERPOLATED_TEXT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MultiLineRawStringLiteralTokenContext {
        rule_index: 235,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> MultiLineRawStringLiteralTokenContext<'a, State> {
    pub fn ml_raw_string_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 186)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MultiLineRawStringLiteralTokenContext", "ML_RAW_STRING_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MultiLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn ml_raw_string_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 186).next() else {
            unreachable!("validated MultiLineRawStringLiteralTokenContext is missing required child ML_RAW_STRING_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SingleLineRawStringLiteralTokenContext {
        rule_index: 236,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> SingleLineRawStringLiteralTokenContext<'a, State> {
    pub fn sl_raw_string_lit_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 185)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SingleLineRawStringLiteralTokenContext", "SL_RAW_STRING_LIT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SingleLineRawStringLiteralTokenContext<'a, ValidatedTreeContext> {
    pub fn sl_raw_string_lit_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 185).next() else {
            unreachable!("validated SingleLineRawStringLiteralTokenContext is missing required child SL_RAW_STRING_LIT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordKeywordContext {
        rule_index: 237,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RecordKeywordContext<'a, State> {
    pub fn kw_record_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 176)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordKeywordContext", "KW_RECORD"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordKeywordContext<'a, ValidatedTreeContext> {
    pub fn kw_record_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 176).next() else {
            unreachable!("validated RecordKeywordContext is missing required child KW_RECORD")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RightShiftContext {
        rule_index: 238,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RightShiftContext<'a, State> {
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RightShiftContext<'a, ValidatedTreeContext> {
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnsignedRightShiftContext {
        rule_index: 239,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnsignedRightShiftContext<'a, State> {
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnsignedRightShiftContext<'a, ValidatedTreeContext> {
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RightShiftAssignmentContext {
        rule_index: 240,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> RightShiftAssignmentContext<'a, State> {
    pub fn ge_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RightShiftAssignmentContext", "GE"))
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 170)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RightShiftAssignmentContext", "GT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RightShiftAssignmentContext<'a, ValidatedTreeContext> {
    pub fn ge_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 139).next() else {
            unreachable!("validated RightShiftAssignmentContext is missing required child GE")
        };
        TerminalNode::new(node)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 170).next() else {
            unreachable!("validated RightShiftAssignmentContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnsignedRightShiftAssignmentContext {
        rule_index: 241,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> UnsignedRightShiftAssignmentContext<'a, State> {
    pub fn ge_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 139)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnsignedRightShiftAssignmentContext", "GE"))
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnsignedRightShiftAssignmentContext<'a, ValidatedTreeContext> {
    pub fn ge_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 139).next() else {
            unreachable!("validated UnsignedRightShiftAssignmentContext is missing required child GE")
        };
        TerminalNode::new(node)
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 170).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalVariableDeclarationContext {
        rule_index: 242,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LocalVariableDeclarationContext<'a, State> {
    pub fn r#type(&self) -> Result<TypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 76)
            .next()
            .map(|node| TypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalVariableDeclarationContext", "type"))
    }
    pub fn local_variable_declarator_children(&self) -> impl Iterator<Item = LocalVariableDeclaratorContext<'a>> + '_ {
        __rule_children(self.__node, 243)
            .map(move |node| LocalVariableDeclaratorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalVariableDeclarationContext<'a, ValidatedTreeContext> {
    pub fn r#type(&self) -> TypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 76).next() else {
            unreachable!("validated LocalVariableDeclarationContext is missing required child type")
        };
        TypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn local_variable_declarator_children(&self) -> impl Iterator<Item = LocalVariableDeclaratorContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 243)
            .map(move |node| LocalVariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 163).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalVariableDeclaratorContext {
        rule_index: 243,
        context_kind: any,
        attributes: {
        },
        methods: {
            rule_node: rule_node,
            child_count: child_count,
            direct_terminals: direct_terminals,
            start: start,
            text: text,
        }
    }
}

#[allow(dead_code, private_bounds, clippy::all)]
impl<'a, State: __RecoveryContextState> LocalVariableDeclaratorContext<'a, State> {
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> Result<IdentifierTokenContext<'a>, MissingChildError> {
        __rule_children(self.__node, 221)
            .next()
            .map(|node| IdentifierTokenContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LocalVariableDeclaratorContext", "identifier_token"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalVariableDeclaratorContext<'a, ValidatedTreeContext> {
    pub fn equals_value_clause(&self) -> Option<EqualsValueClauseContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_token(&self) -> IdentifierTokenContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 221).next() else {
            unreachable!("validated LocalVariableDeclaratorContext is missing required child identifier_token")
        };
        IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

/// Checks generated required-child invariants without changing the
/// recovery-oriented tree's type.
///
/// Strict parsing calls this after proving that lexer and parser syntax-error
/// counts are both zero. It is public so structural runtime/codegen invariant
/// failures can be diagnosed independently.
pub fn validate_tree_structure(
    parsed: &antlr4_runtime::ParsedFile,
) -> Result<(), CSharpValidationError> {
    let tree = parsed.tree();
    if tree.as_rule().is_none() {
        return Err(CSharpValidationError::InvalidRoot);
    }
    for node in tree.descendants() {
        match node.kind() {
            antlr4_runtime::NodeKind::Terminal => {}
            antlr4_runtime::NodeKind::Error => {
                let symbol = node
                    .as_error()
                    .expect("error node kind checked")
                    .symbol();
                return Err(CSharpValidationError::RecoveredErrorNode {
                    line: symbol.line(),
                    column: symbol.column(),
                    text: symbol.text_or_empty().to_owned(),
                });
            }
            antlr4_runtime::NodeKind::Rule => {
                let context = node.as_rule().expect("rule node kind checked");
                match __context_kind(context) {
                0 => {
                    let context = CompilationUnitContext::__from_listener_node(context, None);
        let _ = context.eof_token().map_err(CSharpValidationError::MissingChild)?;
                },
                1 => {
                    let context = ExternAliasDirectiveContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_extern_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_alias_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                2 => {
                    let context = UsingDirectiveContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_using_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                3 => {
                    let context = NameEqualsContext::__from_listener_node(context, None);
        let _ = context.identifier_name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.eq_token().map_err(CSharpValidationError::MissingChild)?;
                },
                4 => {
                },
                5 => {
                    let context = AttributeListContext::__from_listener_node(context, None);
        {
            let actual = context.attribute_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "AttributeListContext",
                    child: "attribute",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                6 => {
                    let context = AttributeTargetSpecifierContext::__from_listener_node(context, None);
        let _ = context.syntax_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                7 => {
                    let context = AttributeContext::__from_listener_node(context, None);
        let _ = context.name().map_err(CSharpValidationError::MissingChild)?;
                },
                8 => {
                },
                9 => {
                    let context = AliasQualifiedNameContext::__from_listener_node(context, None);
        let _ = context.identifier_name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.simple_name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                10 => {
                },
                11 => {
                    let context = GenericNameContext::__from_listener_node(context, None);
        let _ = context.type_argument_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                12 => {
                    let context = TypeArgumentListContext::__from_listener_node(context, None);
        let _ = context.lt_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(CSharpValidationError::MissingChild)?;
                },
                13 => {
                    let context = AttributeArgumentListContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                14 => {
                    let context = AttributeArgumentContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                15 => {
                    let context = NameColonContext::__from_listener_node(context, None);
        let _ = context.identifier_name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                16 => {
                },
                17 => {
                },
                18 => {
                    let context = EventFieldDeclarationContext::__from_listener_node(context, None);
        let _ = context.variable_declaration().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_event_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                19 => {
                },
                20 => {
                    let context = VariableDeclarationContext::__from_listener_node(context, None);
        {
            let actual = context.variable_declarator_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "VariableDeclarationContext",
                    child: "variable_declarator",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                21 => {
                    let context = VariableDeclaratorContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                22 => {
                    let context = BracketedArgumentListContext::__from_listener_node(context, None);
        {
            let actual = context.argument_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "BracketedArgumentListContext",
                    child: "argument",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                23 => {
                    let context = ArgumentContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                24 => {
                    let context = EqualsValueClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.eq_token().map_err(CSharpValidationError::MissingChild)?;
                },
                25 => {
                    let context = FieldDeclarationContext::__from_listener_node(context, None);
        let _ = context.variable_declaration().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                26 => {
                },
                27 => {
                    let context = ConstructorDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                28 => {
                    let context = ParameterListContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                29 => {
                },
                30 => {
                    let context = ConstructorInitializerContext::__from_listener_node(context, None);
        let _ = context.argument_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                31 => {
                    let context = ArgumentListContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                32 => {
                    let context = BlockContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                33 => {
                    let context = ArrowExpressionClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.arrow_token().map_err(CSharpValidationError::MissingChild)?;
                },
                34 => {
                    let context = ConversionOperatorDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_operator_token().map_err(CSharpValidationError::MissingChild)?;
                },
                35 => {
                    let context = ExplicitInterfaceSpecifierContext::__from_listener_node(context, None);
        let _ = context.name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.dot_token().map_err(CSharpValidationError::MissingChild)?;
                },
                36 => {
                    let context = DestructorDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.tilde_token().map_err(CSharpValidationError::MissingChild)?;
                },
                37 => {
                    let context = MethodDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                38 => {
                    let context = TypeParameterListContext::__from_listener_node(context, None);
        {
            let actual = context.type_parameter_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TypeParameterListContext",
                    child: "type_parameter",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lt_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(CSharpValidationError::MissingChild)?;
                },
                39 => {
                    let context = TypeParameterContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                40 => {
                    let context = TypeParameterConstraintClauseContext::__from_listener_node(context, None);
        let _ = context.identifier_name().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.type_parameter_constraint_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TypeParameterConstraintClauseContext",
                    child: "type_parameter_constraint",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.kw_where_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                41 => {
                },
                42 => {
                    let context = AllowsConstraintClauseContext::__from_listener_node(context, None);
        {
            let actual = context.allows_constraint_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "AllowsConstraintClauseContext",
                    child: "allows_constraint",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.kw_allows_token().map_err(CSharpValidationError::MissingChild)?;
                },
                43 => {
                    let context = AllowsConstraintContext::__from_listener_node(context, None);
        let _ = context.ref_struct_constraint().map_err(CSharpValidationError::MissingChild)?;
                },
                44 => {
                    let context = RefStructConstraintContext::__from_listener_node(context, None);
        let _ = context.kw_struct_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_ref_token().map_err(CSharpValidationError::MissingChild)?;
                },
                45 => {
                },
                46 => {
                    let context = ConstructorConstraintContext::__from_listener_node(context, None);
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                47 => {
                    let context = DefaultConstraintContext::__from_listener_node(context, None);
        let _ = context.kw_default_token().map_err(CSharpValidationError::MissingChild)?;
                },
                48 => {
                    let context = TypeConstraintContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                49 => {
                    let context = OperatorDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_operator_token().map_err(CSharpValidationError::MissingChild)?;
                },
                50 => {
                },
                51 => {
                    let context = FileScopedNamespaceDeclarationContext::__from_listener_node(context, None);
        let _ = context.name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_namespace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                52 => {
                    let context = NamespaceDeclarationContext::__from_listener_node(context, None);
        let _ = context.name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_namespace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                53 => {
                },
                54 => {
                    let context = EventDeclarationContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_event_token().map_err(CSharpValidationError::MissingChild)?;
                },
                55 => {
                    let context = AccessorListContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                56 => {
                },
                57 => {
                    let context = IndexerDeclarationContext::__from_listener_node(context, None);
        let _ = context.bracketed_parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_this_token().map_err(CSharpValidationError::MissingChild)?;
                },
                58 => {
                    let context = BracketedParameterListContext::__from_listener_node(context, None);
        {
            let actual = context.parameter_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "BracketedParameterListContext",
                    child: "parameter",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                59 => {
                    let context = PropertyDeclarationContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                60 => {
                },
                61 => {
                    let context = EnumDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_enum_token().map_err(CSharpValidationError::MissingChild)?;
                },
                62 => {
                    let context = BaseListContext::__from_listener_node(context, None);
        {
            let actual = context.base_type_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "BaseListContext",
                    child: "base_type",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                63 => {
                },
                64 => {
                    let context = PrimaryConstructorBaseTypeContext::__from_listener_node(context, None);
        let _ = context.argument_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                65 => {
                    let context = SimpleBaseTypeContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                66 => {
                    let context = EnumMemberDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                67 => {
                },
                68 => {
                    let context = ClassDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_class_token().map_err(CSharpValidationError::MissingChild)?;
                },
                69 => {
                    let context = ExtensionBlockDeclarationContext::__from_listener_node(context, None);
        let _ = context.kw_extension_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                70 => {
                    let context = InterfaceDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_interface_token().map_err(CSharpValidationError::MissingChild)?;
                },
                71 => {
                    let context = RecordDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.record_keyword().map_err(CSharpValidationError::MissingChild)?;
                },
                72 => {
                    let context = StructDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_struct_token().map_err(CSharpValidationError::MissingChild)?;
                },
                73 => {
                    let context = UnionDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_union_token().map_err(CSharpValidationError::MissingChild)?;
                },
                74 => {
                    let context = DelegateDeclarationContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_delegate_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                75 => {
                    let context = GlobalStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
                },
                76 => {
                },
                77 => {
                    let context = ArrayTypeContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.array_rank_specifier_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "ArrayTypeContext",
                    child: "array_rank_specifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                78 => {
                    let context = ArrayRankSpecifierContext::__from_listener_node(context, None);
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                79 => {
                    let context = FunctionPointerTypeContext::__from_listener_node(context, None);
        let _ = context.function_pointer_parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_delegate_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.star_token().map_err(CSharpValidationError::MissingChild)?;
                },
                80 => {
                },
                81 => {
                    let context = FunctionPointerUnmanagedCallingConventionListContext::__from_listener_node(context, None);
        {
            let actual = context.function_pointer_unmanaged_calling_convention_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "FunctionPointerUnmanagedCallingConventionListContext",
                    child: "function_pointer_unmanaged_calling_convention",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                82 => {
                    let context = FunctionPointerUnmanagedCallingConventionContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                83 => {
                    let context = FunctionPointerParameterListContext::__from_listener_node(context, None);
        {
            let actual = context.function_pointer_parameter_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "FunctionPointerParameterListContext",
                    child: "function_pointer_parameter",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lt_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(CSharpValidationError::MissingChild)?;
                },
                84 => {
                    let context = FunctionPointerParameterContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                85 => {
                },
                86 => {
                    let context = RefTypeContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_ref_token().map_err(CSharpValidationError::MissingChild)?;
                },
                87 => {
                    let context = ScopedTypeContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_scoped_token().map_err(CSharpValidationError::MissingChild)?;
                },
                88 => {
                    let context = TupleTypeContext::__from_listener_node(context, None);
        {
            let actual = context.tuple_element_children().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TupleTypeContext",
                    child: "tuple_element",
                    minimum: 2,
                    actual,
                });
            }
        }
        {
            let actual = context.comma_tokens().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TupleTypeContext",
                    child: "COMMA",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                89 => {
                    let context = TupleElementContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                90 => {
                },
                91 => {
                    let context = BreakStatementContext::__from_listener_node(context, None);
        let _ = context.kw_break_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                92 => {
                    let context = CheckedStatementContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
                },
                93 => {
                },
                94 => {
                    let context = ForEachStatementContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_foreach_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_in_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                95 => {
                    let context = ForEachVariableStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.expression_children().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "ForEachVariableStatementContext",
                    child: "expression",
                    minimum: 2,
                    actual,
                });
            }
        }
        let _ = context.kw_foreach_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_in_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                96 => {
                    let context = ContinueStatementContext::__from_listener_node(context, None);
        let _ = context.kw_continue_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                97 => {
                    let context = DoStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_while_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_do_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                98 => {
                    let context = EmptyStatementContext::__from_listener_node(context, None);
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                99 => {
                    let context = ExpressionStatementContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                100 => {
                    let context = FixedStatementContext::__from_listener_node(context, None);
        let _ = context.variable_declaration().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_fixed_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                101 => {
                    let context = ForStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_for_token().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.semicolon_tokens().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "ForStatementContext",
                    child: "SEMICOLON",
                    minimum: 2,
                    actual,
                });
            }
        }
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                102 => {
                    let context = GotoStatementContext::__from_listener_node(context, None);
        let _ = context.kw_goto_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                103 => {
                    let context = IfStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_if_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                104 => {
                    let context = ElseClauseContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_else_token().map_err(CSharpValidationError::MissingChild)?;
                },
                105 => {
                    let context = LabeledStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                106 => {
                    let context = LocalDeclarationStatementContext::__from_listener_node(context, None);
        let _ = context.local_variable_declaration().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                107 => {
                    let context = LocalFunctionStatementContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                108 => {
                    let context = LockStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_lock_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                109 => {
                    let context = ReturnStatementContext::__from_listener_node(context, None);
        let _ = context.kw_return_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                110 => {
                    let context = SwitchStatementContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_switch_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                111 => {
                    let context = SwitchSectionContext::__from_listener_node(context, None);
        {
            let actual = context.statement_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "SwitchSectionContext",
                    child: "statement",
                    minimum: 1,
                    actual,
                });
            }
        }
        {
            let actual = context.switch_label_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "SwitchSectionContext",
                    child: "switch_label",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                112 => {
                },
                113 => {
                    let context = CasePatternSwitchLabelContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_case_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                114 => {
                },
                115 => {
                    let context = ConstantPatternContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                116 => {
                    let context = DeclarationPatternContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.variable_designation().map_err(CSharpValidationError::MissingChild)?;
                },
                117 => {
                },
                118 => {
                    let context = DiscardDesignationContext::__from_listener_node(context, None);
        let _ = context.kw_token().map_err(CSharpValidationError::MissingChild)?;
                },
                119 => {
                    let context = ParenthesizedVariableDesignationContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                120 => {
                },
                121 => {
                    let context = DiscardPatternContext::__from_listener_node(context, None);
        let _ = context.kw_token().map_err(CSharpValidationError::MissingChild)?;
                },
                122 => {
                    let context = ListPatternContext::__from_listener_node(context, None);
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                123 => {
                    let context = ParenthesizedPatternContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                124 => {
                },
                125 => {
                    let context = PositionalPatternClauseContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                126 => {
                    let context = SubpatternContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(CSharpValidationError::MissingChild)?;
                },
                127 => {
                },
                128 => {
                    let context = ExpressionColonContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                129 => {
                    let context = PropertyPatternClauseContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                130 => {
                    let context = RelationalPatternContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                131 => {
                    let context = SlicePatternContext::__from_listener_node(context, None);
        let _ = context.dot_dot_token().map_err(CSharpValidationError::MissingChild)?;
                },
                132 => {
                    let context = TypePatternContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
                },
                133 => {
                    let context = UnaryPatternContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_not_token().map_err(CSharpValidationError::MissingChild)?;
                },
                134 => {
                    let context = VarPatternContext::__from_listener_node(context, None);
        let _ = context.variable_designation().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_var_token().map_err(CSharpValidationError::MissingChild)?;
                },
                135 => {
                    let context = WhenClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_when_token().map_err(CSharpValidationError::MissingChild)?;
                },
                136 => {
                    let context = CaseSwitchLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_case_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                137 => {
                    let context = DefaultSwitchLabelContext::__from_listener_node(context, None);
        let _ = context.kw_default_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                138 => {
                    let context = ThrowStatementContext::__from_listener_node(context, None);
        let _ = context.kw_throw_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                139 => {
                    let context = TryStatementContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_try_token().map_err(CSharpValidationError::MissingChild)?;
                },
                140 => {
                    let context = CatchClauseContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_catch_token().map_err(CSharpValidationError::MissingChild)?;
                },
                141 => {
                    let context = CatchDeclarationContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                142 => {
                    let context = CatchFilterClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_when_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                143 => {
                    let context = FinallyClauseContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_finally_token().map_err(CSharpValidationError::MissingChild)?;
                },
                144 => {
                    let context = UnsafeStatementContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_unsafe_token().map_err(CSharpValidationError::MissingChild)?;
                },
                145 => {
                    let context = UsingStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_using_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                146 => {
                    let context = WhileStatementContext::__from_listener_node(context, None);
        let _ = context.statement().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_while_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                147 => {
                    let context = YieldStatementContext::__from_listener_node(context, None);
        let _ = context.kw_yield_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.semicolon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                148 => {
                },
                149 => {
                },
                150 => {
                    let context = AnonymousMethodExpressionContext::__from_listener_node(context, None);
        let _ = context.block().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_delegate_token().map_err(CSharpValidationError::MissingChild)?;
                },
                151 => {
                },
                152 => {
                    let context = ParenthesizedLambdaExpressionContext::__from_listener_node(context, None);
        let _ = context.parameter_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.arrow_token().map_err(CSharpValidationError::MissingChild)?;
                },
                153 => {
                    let context = SimpleLambdaExpressionContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.arrow_token().map_err(CSharpValidationError::MissingChild)?;
                },
                154 => {
                    let context = AnonymousObjectCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                155 => {
                    let context = AnonymousObjectMemberDeclaratorContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                156 => {
                    let context = ArrayCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.array_type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
                },
                157 => {
                    let context = InitializerExpressionContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                158 => {
                    let context = AwaitExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_await_token().map_err(CSharpValidationError::MissingChild)?;
                },
                159 => {
                },
                160 => {
                    let context = ImplicitObjectCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.argument_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
                },
                161 => {
                    let context = ObjectCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
                },
                162 => {
                    let context = CastExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                163 => {
                    let context = CheckedExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                164 => {
                    let context = CollectionExpressionContext::__from_listener_node(context, None);
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                165 => {
                },
                166 => {
                    let context = ExpressionElementContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                167 => {
                    let context = SpreadElementContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.dot_dot_token().map_err(CSharpValidationError::MissingChild)?;
                },
                168 => {
                    let context = WithElementContext::__from_listener_node(context, None);
        let _ = context.argument_list().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_with_token().map_err(CSharpValidationError::MissingChild)?;
                },
                169 => {
                    let context = DeclarationExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.variable_designation().map_err(CSharpValidationError::MissingChild)?;
                },
                170 => {
                    let context = DefaultExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_default_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                171 => {
                    let context = ElementBindingExpressionContext::__from_listener_node(context, None);
        let _ = context.bracketed_argument_list().map_err(CSharpValidationError::MissingChild)?;
                },
                172 => {
                    let context = FieldExpressionContext::__from_listener_node(context, None);
        let _ = context.kw_field_token().map_err(CSharpValidationError::MissingChild)?;
                },
                173 => {
                    let context = ImplicitArrayCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.initializer_expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_new_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                174 => {
                    let context = ImplicitElementAccessContext::__from_listener_node(context, None);
        let _ = context.bracketed_argument_list().map_err(CSharpValidationError::MissingChild)?;
                },
                175 => {
                    let context = ImplicitStackAllocArrayCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.initializer_expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_stackalloc_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbracket_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbracket_token().map_err(CSharpValidationError::MissingChild)?;
                },
                176 => {
                },
                177 => {
                    let context = BaseExpressionContext::__from_listener_node(context, None);
        let _ = context.kw_base_token().map_err(CSharpValidationError::MissingChild)?;
                },
                178 => {
                    let context = ThisExpressionContext::__from_listener_node(context, None);
        let _ = context.kw_this_token().map_err(CSharpValidationError::MissingChild)?;
                },
                179 => {
                },
                180 => {
                },
                181 => {
                    let context = InterpolatedStringTextContext::__from_listener_node(context, None);
        let _ = context.interpolated_string_text_token().map_err(CSharpValidationError::MissingChild)?;
                },
                182 => {
                    let context = InterpolationContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(CSharpValidationError::MissingChild)?;
                },
                183 => {
                    let context = InterpolationAlignmentClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.comma_token().map_err(CSharpValidationError::MissingChild)?;
                },
                184 => {
                    let context = InterpolationFormatClauseContext::__from_listener_node(context, None);
        let _ = context.interpolated_string_text_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(CSharpValidationError::MissingChild)?;
                },
                185 => {
                    let context = InterpolatedMultiLineRawStringStartTokenContext::__from_listener_node(context, None);
        let _ = context.interp_raw_start_token().map_err(CSharpValidationError::MissingChild)?;
                },
                186 => {
                    let context = InterpolatedRawStringEndTokenContext::__from_listener_node(context, None);
        let _ = context.triple_dquote_token().map_err(CSharpValidationError::MissingChild)?;
                },
                187 => {
                    let context = InterpolatedSingleLineRawStringStartTokenContext::__from_listener_node(context, None);
        let _ = context.interp_raw_start_token().map_err(CSharpValidationError::MissingChild)?;
                },
                188 => {
                },
                189 => {
                    let context = Utf8MultiLineRawStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.multi_line_raw_string_literal_token().map_err(CSharpValidationError::MissingChild)?;
                },
                190 => {
                    let context = Utf8SingleLineRawStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.single_line_raw_string_literal_token().map_err(CSharpValidationError::MissingChild)?;
                },
                191 => {
                    let context = Utf8StringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.string_literal_token().map_err(CSharpValidationError::MissingChild)?;
                },
                192 => {
                    let context = MakeRefExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_makeref_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                193 => {
                    let context = MemberBindingExpressionContext::__from_listener_node(context, None);
        let _ = context.simple_name().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.dot_token().map_err(CSharpValidationError::MissingChild)?;
                },
                194 => {
                    let context = ParenthesizedExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                195 => {
                    let context = PrefixUnaryExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                196 => {
                    let context = QueryExpressionContext::__from_listener_node(context, None);
        let _ = context.from_clause().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.query_body().map_err(CSharpValidationError::MissingChild)?;
                },
                197 => {
                    let context = FromClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_from_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_in_token().map_err(CSharpValidationError::MissingChild)?;
                },
                198 => {
                    let context = QueryBodyContext::__from_listener_node(context, None);
        let _ = context.select_or_group_clause().map_err(CSharpValidationError::MissingChild)?;
                },
                199 => {
                },
                200 => {
                    let context = JoinClauseContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 3 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "JoinClauseContext",
                    child: "expression",
                    minimum: 3,
                    actual,
                });
            }
        }
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_equals_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_join_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_in_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_on_token().map_err(CSharpValidationError::MissingChild)?;
                },
                201 => {
                    let context = JoinIntoClauseContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_into_token().map_err(CSharpValidationError::MissingChild)?;
                },
                202 => {
                    let context = LetClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_let_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.eq_token().map_err(CSharpValidationError::MissingChild)?;
                },
                203 => {
                    let context = OrderByClauseContext::__from_listener_node(context, None);
        {
            let actual = context.ordering_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "OrderByClauseContext",
                    child: "ordering",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.kw_orderby_token().map_err(CSharpValidationError::MissingChild)?;
                },
                204 => {
                    let context = OrderingContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
                },
                205 => {
                    let context = WhereClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_where_token().map_err(CSharpValidationError::MissingChild)?;
                },
                206 => {
                },
                207 => {
                    let context = GroupClauseContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "GroupClauseContext",
                    child: "expression",
                    minimum: 2,
                    actual,
                });
            }
        }
        let _ = context.kw_group_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_by_token().map_err(CSharpValidationError::MissingChild)?;
                },
                208 => {
                    let context = SelectClauseContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_select_token().map_err(CSharpValidationError::MissingChild)?;
                },
                209 => {
                    let context = QueryContinuationContext::__from_listener_node(context, None);
        let _ = context.query_body().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_into_token().map_err(CSharpValidationError::MissingChild)?;
                },
                210 => {
                    let context = RefExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_ref_token().map_err(CSharpValidationError::MissingChild)?;
                },
                211 => {
                    let context = RefTypeExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_reftype_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                212 => {
                    let context = RefValueExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_refvalue_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.comma_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                213 => {
                    let context = SizeOfExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_sizeof_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                214 => {
                    let context = StackAllocArrayCreationExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_stackalloc_token().map_err(CSharpValidationError::MissingChild)?;
                },
                215 => {
                    let context = SwitchExpressionArmContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.arrow_token().map_err(CSharpValidationError::MissingChild)?;
                },
                216 => {
                    let context = ThrowExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_throw_token().map_err(CSharpValidationError::MissingChild)?;
                },
                217 => {
                    let context = TupleExpressionContext::__from_listener_node(context, None);
        {
            let actual = context.argument_children().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TupleExpressionContext",
                    child: "argument",
                    minimum: 2,
                    actual,
                });
            }
        }
        {
            let actual = context.comma_tokens().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "TupleExpressionContext",
                    child: "COMMA",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                218 => {
                    let context = TypeOfExpressionContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_typeof_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                219 => {
                    let context = UnsafeExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.kw_unsafe_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(CSharpValidationError::MissingChild)?;
                },
                220 => {
                },
                221 => {
                },
                222 => {
                },
                223 => {
                },
                224 => {
                },
                225 => {
                    let context = DecimalIntegerLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.dec_int_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                226 => {
                    let context = HexadecimalIntegerLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.hex_int_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                227 => {
                    let context = RealLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.real_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                228 => {
                    let context = CharacterLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.char_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                229 => {
                },
                230 => {
                    let context = RegularStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.string_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                231 => {
                    let context = VerbatimStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.verbatim_string_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                232 => {
                },
                233 => {
                },
                234 => {
                    let context = InterpolatedStringTextTokenContext::__from_listener_node(context, None);
        let _ = context.interpolated_text_token().map_err(CSharpValidationError::MissingChild)?;
                },
                235 => {
                    let context = MultiLineRawStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.ml_raw_string_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                236 => {
                    let context = SingleLineRawStringLiteralTokenContext::__from_listener_node(context, None);
        let _ = context.sl_raw_string_lit_token().map_err(CSharpValidationError::MissingChild)?;
                },
                237 => {
                    let context = RecordKeywordContext::__from_listener_node(context, None);
        let _ = context.kw_record_token().map_err(CSharpValidationError::MissingChild)?;
                },
                238 => {
                    let context = RightShiftContext::__from_listener_node(context, None);
        {
            let actual = context.gt_tokens().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "RightShiftContext",
                    child: "GT",
                    minimum: 2,
                    actual,
                });
            }
        }
                },
                239 => {
                    let context = UnsignedRightShiftContext::__from_listener_node(context, None);
        {
            let actual = context.gt_tokens().count();
            if actual < 3 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "UnsignedRightShiftContext",
                    child: "GT",
                    minimum: 3,
                    actual,
                });
            }
        }
                },
                240 => {
                    let context = RightShiftAssignmentContext::__from_listener_node(context, None);
        let _ = context.ge_token().map_err(CSharpValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(CSharpValidationError::MissingChild)?;
                },
                241 => {
                    let context = UnsignedRightShiftAssignmentContext::__from_listener_node(context, None);
        let _ = context.ge_token().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.gt_tokens().count();
            if actual < 2 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "UnsignedRightShiftAssignmentContext",
                    child: "GT",
                    minimum: 2,
                    actual,
                });
            }
        }
                },
                242 => {
                    let context = LocalVariableDeclarationContext::__from_listener_node(context, None);
        let _ = context.r#type().map_err(CSharpValidationError::MissingChild)?;
        {
            let actual = context.local_variable_declarator_children().count();
            if actual < 1 {
                return Err(CSharpValidationError::InvalidChildCount {
                    context: "LocalVariableDeclarationContext",
                    child: "local_variable_declarator",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                243 => {
                    let context = LocalVariableDeclaratorContext::__from_listener_node(context, None);
        let _ = context.identifier_token().map_err(CSharpValidationError::MissingChild)?;
                },
                    _ => {
                        return Err(CSharpValidationError::UnknownRule {
                            rule_index: context.rule_index(),
                        });
                    }
                }
            }
        }
    }
    Ok(())
}

#[allow(dead_code, unused_variables)]
pub trait CSharpListener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: antlr4_runtime::Node<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        CSharpTreeWalker::walk(self, tree)
    }

    fn enter_every_rule(&mut self, _ctx: RuleNodeView<'_>) -> Result<(), E> { Ok(()) }
    fn exit_every_rule(&mut self, _ctx: RuleNodeView<'_>) -> Result<(), E> { Ok(()) }

    fn enter_compilation_unit(&mut self, _ctx: &CompilationUnitContext) -> Result<(), E> { Ok(()) }
    fn exit_compilation_unit(&mut self, _ctx: &CompilationUnitContext) -> Result<(), E> { Ok(()) }
    fn enter_extern_alias_directive(&mut self, _ctx: &ExternAliasDirectiveContext) -> Result<(), E> { Ok(()) }
    fn exit_extern_alias_directive(&mut self, _ctx: &ExternAliasDirectiveContext) -> Result<(), E> { Ok(()) }
    fn enter_using_directive(&mut self, _ctx: &UsingDirectiveContext) -> Result<(), E> { Ok(()) }
    fn exit_using_directive(&mut self, _ctx: &UsingDirectiveContext) -> Result<(), E> { Ok(()) }
    fn enter_name_equals(&mut self, _ctx: &NameEqualsContext) -> Result<(), E> { Ok(()) }
    fn exit_name_equals(&mut self, _ctx: &NameEqualsContext) -> Result<(), E> { Ok(()) }
    fn enter_identifier_name(&mut self, _ctx: &IdentifierNameContext) -> Result<(), E> { Ok(()) }
    fn exit_identifier_name(&mut self, _ctx: &IdentifierNameContext) -> Result<(), E> { Ok(()) }
    fn enter_attribute_list(&mut self, _ctx: &AttributeListContext) -> Result<(), E> { Ok(()) }
    fn exit_attribute_list(&mut self, _ctx: &AttributeListContext) -> Result<(), E> { Ok(()) }
    fn enter_attribute_target_specifier(&mut self, _ctx: &AttributeTargetSpecifierContext) -> Result<(), E> { Ok(()) }
    fn exit_attribute_target_specifier(&mut self, _ctx: &AttributeTargetSpecifierContext) -> Result<(), E> { Ok(()) }
    fn enter_attribute(&mut self, _ctx: &AttributeContext) -> Result<(), E> { Ok(()) }
    fn exit_attribute(&mut self, _ctx: &AttributeContext) -> Result<(), E> { Ok(()) }
    fn enter_name(&mut self, _ctx: &NameContext) -> Result<(), E> { Ok(()) }
    fn exit_name(&mut self, _ctx: &NameContext) -> Result<(), E> { Ok(()) }
    fn enter_alias_qualified_name(&mut self, _ctx: &AliasQualifiedNameContext) -> Result<(), E> { Ok(()) }
    fn exit_alias_qualified_name(&mut self, _ctx: &AliasQualifiedNameContext) -> Result<(), E> { Ok(()) }
    fn enter_simple_name(&mut self, _ctx: &SimpleNameContext) -> Result<(), E> { Ok(()) }
    fn exit_simple_name(&mut self, _ctx: &SimpleNameContext) -> Result<(), E> { Ok(()) }
    fn enter_generic_name(&mut self, _ctx: &GenericNameContext) -> Result<(), E> { Ok(()) }
    fn exit_generic_name(&mut self, _ctx: &GenericNameContext) -> Result<(), E> { Ok(()) }
    fn enter_type_argument_list(&mut self, _ctx: &TypeArgumentListContext) -> Result<(), E> { Ok(()) }
    fn exit_type_argument_list(&mut self, _ctx: &TypeArgumentListContext) -> Result<(), E> { Ok(()) }
    fn enter_attribute_argument_list(&mut self, _ctx: &AttributeArgumentListContext) -> Result<(), E> { Ok(()) }
    fn exit_attribute_argument_list(&mut self, _ctx: &AttributeArgumentListContext) -> Result<(), E> { Ok(()) }
    fn enter_attribute_argument(&mut self, _ctx: &AttributeArgumentContext) -> Result<(), E> { Ok(()) }
    fn exit_attribute_argument(&mut self, _ctx: &AttributeArgumentContext) -> Result<(), E> { Ok(()) }
    fn enter_name_colon(&mut self, _ctx: &NameColonContext) -> Result<(), E> { Ok(()) }
    fn exit_name_colon(&mut self, _ctx: &NameColonContext) -> Result<(), E> { Ok(()) }
    fn enter_member_declaration(&mut self, _ctx: &MemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_member_declaration(&mut self, _ctx: &MemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_field_declaration(&mut self, _ctx: &BaseFieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_base_field_declaration(&mut self, _ctx: &BaseFieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_event_field_declaration(&mut self, _ctx: &EventFieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_event_field_declaration(&mut self, _ctx: &EventFieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_modifier(&mut self, _ctx: &ModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_modifier(&mut self, _ctx: &ModifierContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_declaration(&mut self, _ctx: &VariableDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_declaration(&mut self, _ctx: &VariableDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_declarator(&mut self, _ctx: &VariableDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarator(&mut self, _ctx: &VariableDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn enter_bracketed_argument_list(&mut self, _ctx: &BracketedArgumentListContext) -> Result<(), E> { Ok(()) }
    fn exit_bracketed_argument_list(&mut self, _ctx: &BracketedArgumentListContext) -> Result<(), E> { Ok(()) }
    fn enter_argument(&mut self, _ctx: &ArgumentContext) -> Result<(), E> { Ok(()) }
    fn exit_argument(&mut self, _ctx: &ArgumentContext) -> Result<(), E> { Ok(()) }
    fn enter_equals_value_clause(&mut self, _ctx: &EqualsValueClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_equals_value_clause(&mut self, _ctx: &EqualsValueClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_field_declaration(&mut self, _ctx: &FieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_field_declaration(&mut self, _ctx: &FieldDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_method_declaration(&mut self, _ctx: &BaseMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_base_method_declaration(&mut self, _ctx: &BaseMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_constructor_declaration(&mut self, _ctx: &ConstructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_constructor_declaration(&mut self, _ctx: &ConstructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_parameter_list(&mut self, _ctx: &ParameterListContext) -> Result<(), E> { Ok(()) }
    fn exit_parameter_list(&mut self, _ctx: &ParameterListContext) -> Result<(), E> { Ok(()) }
    fn enter_parameter(&mut self, _ctx: &ParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_parameter(&mut self, _ctx: &ParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_constructor_initializer(&mut self, _ctx: &ConstructorInitializerContext) -> Result<(), E> { Ok(()) }
    fn exit_constructor_initializer(&mut self, _ctx: &ConstructorInitializerContext) -> Result<(), E> { Ok(()) }
    fn enter_argument_list(&mut self, _ctx: &ArgumentListContext) -> Result<(), E> { Ok(()) }
    fn exit_argument_list(&mut self, _ctx: &ArgumentListContext) -> Result<(), E> { Ok(()) }
    fn enter_block(&mut self, _ctx: &BlockContext) -> Result<(), E> { Ok(()) }
    fn exit_block(&mut self, _ctx: &BlockContext) -> Result<(), E> { Ok(()) }
    fn enter_arrow_expression_clause(&mut self, _ctx: &ArrowExpressionClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_arrow_expression_clause(&mut self, _ctx: &ArrowExpressionClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_conversion_operator_declaration(&mut self, _ctx: &ConversionOperatorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_conversion_operator_declaration(&mut self, _ctx: &ConversionOperatorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_explicit_interface_specifier(&mut self, _ctx: &ExplicitInterfaceSpecifierContext) -> Result<(), E> { Ok(()) }
    fn exit_explicit_interface_specifier(&mut self, _ctx: &ExplicitInterfaceSpecifierContext) -> Result<(), E> { Ok(()) }
    fn enter_destructor_declaration(&mut self, _ctx: &DestructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_destructor_declaration(&mut self, _ctx: &DestructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_method_declaration(&mut self, _ctx: &MethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_method_declaration(&mut self, _ctx: &MethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_list(&mut self, _ctx: &TypeParameterListContext) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_list(&mut self, _ctx: &TypeParameterListContext) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter(&mut self, _ctx: &TypeParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter(&mut self, _ctx: &TypeParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_constraint_clause(&mut self, _ctx: &TypeParameterConstraintClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_constraint_clause(&mut self, _ctx: &TypeParameterConstraintClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_constraint(&mut self, _ctx: &TypeParameterConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_constraint(&mut self, _ctx: &TypeParameterConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_allows_constraint_clause(&mut self, _ctx: &AllowsConstraintClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_allows_constraint_clause(&mut self, _ctx: &AllowsConstraintClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_allows_constraint(&mut self, _ctx: &AllowsConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_allows_constraint(&mut self, _ctx: &AllowsConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_ref_struct_constraint(&mut self, _ctx: &RefStructConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_ref_struct_constraint(&mut self, _ctx: &RefStructConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_class_or_struct_constraint(&mut self, _ctx: &ClassOrStructConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_class_or_struct_constraint(&mut self, _ctx: &ClassOrStructConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_constructor_constraint(&mut self, _ctx: &ConstructorConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_constructor_constraint(&mut self, _ctx: &ConstructorConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_default_constraint(&mut self, _ctx: &DefaultConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_default_constraint(&mut self, _ctx: &DefaultConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_type_constraint(&mut self, _ctx: &TypeConstraintContext) -> Result<(), E> { Ok(()) }
    fn exit_type_constraint(&mut self, _ctx: &TypeConstraintContext) -> Result<(), E> { Ok(()) }
    fn enter_operator_declaration(&mut self, _ctx: &OperatorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_operator_declaration(&mut self, _ctx: &OperatorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_namespace_declaration(&mut self, _ctx: &BaseNamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_base_namespace_declaration(&mut self, _ctx: &BaseNamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_file_scoped_namespace_declaration(&mut self, _ctx: &FileScopedNamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_file_scoped_namespace_declaration(&mut self, _ctx: &FileScopedNamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_namespace_declaration(&mut self, _ctx: &NamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_namespace_declaration(&mut self, _ctx: &NamespaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_property_declaration(&mut self, _ctx: &BasePropertyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_base_property_declaration(&mut self, _ctx: &BasePropertyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_event_declaration(&mut self, _ctx: &EventDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_event_declaration(&mut self, _ctx: &EventDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_accessor_list(&mut self, _ctx: &AccessorListContext) -> Result<(), E> { Ok(()) }
    fn exit_accessor_list(&mut self, _ctx: &AccessorListContext) -> Result<(), E> { Ok(()) }
    fn enter_accessor_declaration(&mut self, _ctx: &AccessorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_accessor_declaration(&mut self, _ctx: &AccessorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_indexer_declaration(&mut self, _ctx: &IndexerDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_indexer_declaration(&mut self, _ctx: &IndexerDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_bracketed_parameter_list(&mut self, _ctx: &BracketedParameterListContext) -> Result<(), E> { Ok(()) }
    fn exit_bracketed_parameter_list(&mut self, _ctx: &BracketedParameterListContext) -> Result<(), E> { Ok(()) }
    fn enter_property_declaration(&mut self, _ctx: &PropertyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_property_declaration(&mut self, _ctx: &PropertyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_type_declaration(&mut self, _ctx: &BaseTypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_base_type_declaration(&mut self, _ctx: &BaseTypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_enum_declaration(&mut self, _ctx: &EnumDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_enum_declaration(&mut self, _ctx: &EnumDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_base_list(&mut self, _ctx: &BaseListContext) -> Result<(), E> { Ok(()) }
    fn exit_base_list(&mut self, _ctx: &BaseListContext) -> Result<(), E> { Ok(()) }
    fn enter_base_type(&mut self, _ctx: &BaseTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_base_type(&mut self, _ctx: &BaseTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_primary_constructor_base_type(&mut self, _ctx: &PrimaryConstructorBaseTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_primary_constructor_base_type(&mut self, _ctx: &PrimaryConstructorBaseTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_simple_base_type(&mut self, _ctx: &SimpleBaseTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_simple_base_type(&mut self, _ctx: &SimpleBaseTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_enum_member_declaration(&mut self, _ctx: &EnumMemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_enum_member_declaration(&mut self, _ctx: &EnumMemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_type_declaration(&mut self, _ctx: &TypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_type_declaration(&mut self, _ctx: &TypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_class_declaration(&mut self, _ctx: &ClassDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_class_declaration(&mut self, _ctx: &ClassDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_extension_block_declaration(&mut self, _ctx: &ExtensionBlockDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_extension_block_declaration(&mut self, _ctx: &ExtensionBlockDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_declaration(&mut self, _ctx: &InterfaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_declaration(&mut self, _ctx: &InterfaceDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_record_declaration(&mut self, _ctx: &RecordDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_record_declaration(&mut self, _ctx: &RecordDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_struct_declaration(&mut self, _ctx: &StructDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_struct_declaration(&mut self, _ctx: &StructDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_union_declaration(&mut self, _ctx: &UnionDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_union_declaration(&mut self, _ctx: &UnionDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_delegate_declaration(&mut self, _ctx: &DelegateDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_delegate_declaration(&mut self, _ctx: &DelegateDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_global_statement(&mut self, _ctx: &GlobalStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_global_statement(&mut self, _ctx: &GlobalStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_type(&mut self, _ctx: &TypeContext) -> Result<(), E> { Ok(()) }
    fn exit_type(&mut self, _ctx: &TypeContext) -> Result<(), E> { Ok(()) }
    fn enter_array_type(&mut self, _ctx: &ArrayTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_array_type(&mut self, _ctx: &ArrayTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_array_rank_specifier(&mut self, _ctx: &ArrayRankSpecifierContext) -> Result<(), E> { Ok(()) }
    fn exit_array_rank_specifier(&mut self, _ctx: &ArrayRankSpecifierContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_type(&mut self, _ctx: &FunctionPointerTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_type(&mut self, _ctx: &FunctionPointerTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_calling_convention(&mut self, _ctx: &FunctionPointerCallingConventionContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_calling_convention(&mut self, _ctx: &FunctionPointerCallingConventionContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_unmanaged_calling_convention_list(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionListContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_unmanaged_calling_convention_list(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionListContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_unmanaged_calling_convention(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_unmanaged_calling_convention(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_parameter_list(&mut self, _ctx: &FunctionPointerParameterListContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_parameter_list(&mut self, _ctx: &FunctionPointerParameterListContext) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_parameter(&mut self, _ctx: &FunctionPointerParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_parameter(&mut self, _ctx: &FunctionPointerParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_predefined_type(&mut self, _ctx: &PredefinedTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_predefined_type(&mut self, _ctx: &PredefinedTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_ref_type(&mut self, _ctx: &RefTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_ref_type(&mut self, _ctx: &RefTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_scoped_type(&mut self, _ctx: &ScopedTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_scoped_type(&mut self, _ctx: &ScopedTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_tuple_type(&mut self, _ctx: &TupleTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_tuple_type(&mut self, _ctx: &TupleTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_tuple_element(&mut self, _ctx: &TupleElementContext) -> Result<(), E> { Ok(()) }
    fn exit_tuple_element(&mut self, _ctx: &TupleElementContext) -> Result<(), E> { Ok(()) }
    fn enter_statement(&mut self, _ctx: &StatementContext) -> Result<(), E> { Ok(()) }
    fn exit_statement(&mut self, _ctx: &StatementContext) -> Result<(), E> { Ok(()) }
    fn enter_break_statement(&mut self, _ctx: &BreakStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_break_statement(&mut self, _ctx: &BreakStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_checked_statement(&mut self, _ctx: &CheckedStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_checked_statement(&mut self, _ctx: &CheckedStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_common_for_each_statement(&mut self, _ctx: &CommonForEachStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_common_for_each_statement(&mut self, _ctx: &CommonForEachStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_for_each_statement(&mut self, _ctx: &ForEachStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_for_each_statement(&mut self, _ctx: &ForEachStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_for_each_variable_statement(&mut self, _ctx: &ForEachVariableStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_for_each_variable_statement(&mut self, _ctx: &ForEachVariableStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_continue_statement(&mut self, _ctx: &ContinueStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_continue_statement(&mut self, _ctx: &ContinueStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_do_statement(&mut self, _ctx: &DoStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_do_statement(&mut self, _ctx: &DoStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_empty_statement(&mut self, _ctx: &EmptyStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_empty_statement(&mut self, _ctx: &EmptyStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_statement(&mut self, _ctx: &ExpressionStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_statement(&mut self, _ctx: &ExpressionStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_fixed_statement(&mut self, _ctx: &FixedStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_fixed_statement(&mut self, _ctx: &FixedStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_for_statement(&mut self, _ctx: &ForStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_for_statement(&mut self, _ctx: &ForStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_goto_statement(&mut self, _ctx: &GotoStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_goto_statement(&mut self, _ctx: &GotoStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_if_statement(&mut self, _ctx: &IfStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_if_statement(&mut self, _ctx: &IfStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_else_clause(&mut self, _ctx: &ElseClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_else_clause(&mut self, _ctx: &ElseClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_labeled_statement(&mut self, _ctx: &LabeledStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_labeled_statement(&mut self, _ctx: &LabeledStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_local_declaration_statement(&mut self, _ctx: &LocalDeclarationStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_local_declaration_statement(&mut self, _ctx: &LocalDeclarationStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_local_function_statement(&mut self, _ctx: &LocalFunctionStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_local_function_statement(&mut self, _ctx: &LocalFunctionStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_lock_statement(&mut self, _ctx: &LockStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_lock_statement(&mut self, _ctx: &LockStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_return_statement(&mut self, _ctx: &ReturnStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_return_statement(&mut self, _ctx: &ReturnStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_statement(&mut self, _ctx: &SwitchStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_statement(&mut self, _ctx: &SwitchStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_section(&mut self, _ctx: &SwitchSectionContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_section(&mut self, _ctx: &SwitchSectionContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_label(&mut self, _ctx: &SwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_label(&mut self, _ctx: &SwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_case_pattern_switch_label(&mut self, _ctx: &CasePatternSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_case_pattern_switch_label(&mut self, _ctx: &CasePatternSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_pattern(&mut self, _ctx: &PatternContext) -> Result<(), E> { Ok(()) }
    fn exit_pattern(&mut self, _ctx: &PatternContext) -> Result<(), E> { Ok(()) }
    fn enter_constant_pattern(&mut self, _ctx: &ConstantPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_constant_pattern(&mut self, _ctx: &ConstantPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_declaration_pattern(&mut self, _ctx: &DeclarationPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_declaration_pattern(&mut self, _ctx: &DeclarationPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_designation(&mut self, _ctx: &VariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_designation(&mut self, _ctx: &VariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn enter_discard_designation(&mut self, _ctx: &DiscardDesignationContext) -> Result<(), E> { Ok(()) }
    fn exit_discard_designation(&mut self, _ctx: &DiscardDesignationContext) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_variable_designation(&mut self, _ctx: &ParenthesizedVariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_variable_designation(&mut self, _ctx: &ParenthesizedVariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn enter_single_variable_designation(&mut self, _ctx: &SingleVariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn exit_single_variable_designation(&mut self, _ctx: &SingleVariableDesignationContext) -> Result<(), E> { Ok(()) }
    fn enter_discard_pattern(&mut self, _ctx: &DiscardPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_discard_pattern(&mut self, _ctx: &DiscardPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_list_pattern(&mut self, _ctx: &ListPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_list_pattern(&mut self, _ctx: &ListPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_pattern(&mut self, _ctx: &ParenthesizedPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_pattern(&mut self, _ctx: &ParenthesizedPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_recursive_pattern(&mut self, _ctx: &RecursivePatternContext) -> Result<(), E> { Ok(()) }
    fn exit_recursive_pattern(&mut self, _ctx: &RecursivePatternContext) -> Result<(), E> { Ok(()) }
    fn enter_positional_pattern_clause(&mut self, _ctx: &PositionalPatternClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_positional_pattern_clause(&mut self, _ctx: &PositionalPatternClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_subpattern(&mut self, _ctx: &SubpatternContext) -> Result<(), E> { Ok(()) }
    fn exit_subpattern(&mut self, _ctx: &SubpatternContext) -> Result<(), E> { Ok(()) }
    fn enter_base_expression_colon(&mut self, _ctx: &BaseExpressionColonContext) -> Result<(), E> { Ok(()) }
    fn exit_base_expression_colon(&mut self, _ctx: &BaseExpressionColonContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_colon(&mut self, _ctx: &ExpressionColonContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_colon(&mut self, _ctx: &ExpressionColonContext) -> Result<(), E> { Ok(()) }
    fn enter_property_pattern_clause(&mut self, _ctx: &PropertyPatternClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_property_pattern_clause(&mut self, _ctx: &PropertyPatternClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_relational_pattern(&mut self, _ctx: &RelationalPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_relational_pattern(&mut self, _ctx: &RelationalPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_slice_pattern(&mut self, _ctx: &SlicePatternContext) -> Result<(), E> { Ok(()) }
    fn exit_slice_pattern(&mut self, _ctx: &SlicePatternContext) -> Result<(), E> { Ok(()) }
    fn enter_type_pattern(&mut self, _ctx: &TypePatternContext) -> Result<(), E> { Ok(()) }
    fn exit_type_pattern(&mut self, _ctx: &TypePatternContext) -> Result<(), E> { Ok(()) }
    fn enter_unary_pattern(&mut self, _ctx: &UnaryPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_unary_pattern(&mut self, _ctx: &UnaryPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_var_pattern(&mut self, _ctx: &VarPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_var_pattern(&mut self, _ctx: &VarPatternContext) -> Result<(), E> { Ok(()) }
    fn enter_when_clause(&mut self, _ctx: &WhenClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_when_clause(&mut self, _ctx: &WhenClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_case_switch_label(&mut self, _ctx: &CaseSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_case_switch_label(&mut self, _ctx: &CaseSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_default_switch_label(&mut self, _ctx: &DefaultSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_default_switch_label(&mut self, _ctx: &DefaultSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_throw_statement(&mut self, _ctx: &ThrowStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_throw_statement(&mut self, _ctx: &ThrowStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_try_statement(&mut self, _ctx: &TryStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_try_statement(&mut self, _ctx: &TryStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_catch_clause(&mut self, _ctx: &CatchClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_catch_clause(&mut self, _ctx: &CatchClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_catch_declaration(&mut self, _ctx: &CatchDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_catch_declaration(&mut self, _ctx: &CatchDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_catch_filter_clause(&mut self, _ctx: &CatchFilterClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_catch_filter_clause(&mut self, _ctx: &CatchFilterClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_finally_clause(&mut self, _ctx: &FinallyClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_finally_clause(&mut self, _ctx: &FinallyClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_unsafe_statement(&mut self, _ctx: &UnsafeStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_unsafe_statement(&mut self, _ctx: &UnsafeStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_using_statement(&mut self, _ctx: &UsingStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_using_statement(&mut self, _ctx: &UsingStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_while_statement(&mut self, _ctx: &WhileStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_while_statement(&mut self, _ctx: &WhileStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_yield_statement(&mut self, _ctx: &YieldStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_yield_statement(&mut self, _ctx: &YieldStatementContext) -> Result<(), E> { Ok(()) }
    fn enter_expression(&mut self, _ctx: &ExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_expression(&mut self, _ctx: &ExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_function_expression(&mut self, _ctx: &AnonymousFunctionExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_function_expression(&mut self, _ctx: &AnonymousFunctionExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_method_expression(&mut self, _ctx: &AnonymousMethodExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_method_expression(&mut self, _ctx: &AnonymousMethodExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_lambda_expression(&mut self, _ctx: &LambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_lambda_expression(&mut self, _ctx: &LambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_lambda_expression(&mut self, _ctx: &ParenthesizedLambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_lambda_expression(&mut self, _ctx: &ParenthesizedLambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_simple_lambda_expression(&mut self, _ctx: &SimpleLambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_simple_lambda_expression(&mut self, _ctx: &SimpleLambdaExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_object_creation_expression(&mut self, _ctx: &AnonymousObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_object_creation_expression(&mut self, _ctx: &AnonymousObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_object_member_declarator(&mut self, _ctx: &AnonymousObjectMemberDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_object_member_declarator(&mut self, _ctx: &AnonymousObjectMemberDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn enter_array_creation_expression(&mut self, _ctx: &ArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_array_creation_expression(&mut self, _ctx: &ArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_initializer_expression(&mut self, _ctx: &InitializerExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_initializer_expression(&mut self, _ctx: &InitializerExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_await_expression(&mut self, _ctx: &AwaitExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_await_expression(&mut self, _ctx: &AwaitExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_base_object_creation_expression(&mut self, _ctx: &BaseObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_base_object_creation_expression(&mut self, _ctx: &BaseObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_implicit_object_creation_expression(&mut self, _ctx: &ImplicitObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_implicit_object_creation_expression(&mut self, _ctx: &ImplicitObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_object_creation_expression(&mut self, _ctx: &ObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_object_creation_expression(&mut self, _ctx: &ObjectCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_cast_expression(&mut self, _ctx: &CastExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_cast_expression(&mut self, _ctx: &CastExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_checked_expression(&mut self, _ctx: &CheckedExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_checked_expression(&mut self, _ctx: &CheckedExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_collection_expression(&mut self, _ctx: &CollectionExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_collection_expression(&mut self, _ctx: &CollectionExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_collection_element(&mut self, _ctx: &CollectionElementContext) -> Result<(), E> { Ok(()) }
    fn exit_collection_element(&mut self, _ctx: &CollectionElementContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_element(&mut self, _ctx: &ExpressionElementContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_element(&mut self, _ctx: &ExpressionElementContext) -> Result<(), E> { Ok(()) }
    fn enter_spread_element(&mut self, _ctx: &SpreadElementContext) -> Result<(), E> { Ok(()) }
    fn exit_spread_element(&mut self, _ctx: &SpreadElementContext) -> Result<(), E> { Ok(()) }
    fn enter_with_element(&mut self, _ctx: &WithElementContext) -> Result<(), E> { Ok(()) }
    fn exit_with_element(&mut self, _ctx: &WithElementContext) -> Result<(), E> { Ok(()) }
    fn enter_declaration_expression(&mut self, _ctx: &DeclarationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_declaration_expression(&mut self, _ctx: &DeclarationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_default_expression(&mut self, _ctx: &DefaultExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_default_expression(&mut self, _ctx: &DefaultExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_element_binding_expression(&mut self, _ctx: &ElementBindingExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_element_binding_expression(&mut self, _ctx: &ElementBindingExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_field_expression(&mut self, _ctx: &FieldExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_field_expression(&mut self, _ctx: &FieldExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_implicit_array_creation_expression(&mut self, _ctx: &ImplicitArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_implicit_array_creation_expression(&mut self, _ctx: &ImplicitArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_implicit_element_access(&mut self, _ctx: &ImplicitElementAccessContext) -> Result<(), E> { Ok(()) }
    fn exit_implicit_element_access(&mut self, _ctx: &ImplicitElementAccessContext) -> Result<(), E> { Ok(()) }
    fn enter_implicit_stack_alloc_array_creation_expression(&mut self, _ctx: &ImplicitStackAllocArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_implicit_stack_alloc_array_creation_expression(&mut self, _ctx: &ImplicitStackAllocArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_instance_expression(&mut self, _ctx: &InstanceExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_instance_expression(&mut self, _ctx: &InstanceExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_base_expression(&mut self, _ctx: &BaseExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_base_expression(&mut self, _ctx: &BaseExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_this_expression(&mut self, _ctx: &ThisExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_this_expression(&mut self, _ctx: &ThisExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_expression(&mut self, _ctx: &InterpolatedStringExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_expression(&mut self, _ctx: &InterpolatedStringExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_content(&mut self, _ctx: &InterpolatedStringContentContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_content(&mut self, _ctx: &InterpolatedStringContentContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_text(&mut self, _ctx: &InterpolatedStringTextContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_text(&mut self, _ctx: &InterpolatedStringTextContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolation(&mut self, _ctx: &InterpolationContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolation(&mut self, _ctx: &InterpolationContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolation_alignment_clause(&mut self, _ctx: &InterpolationAlignmentClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolation_alignment_clause(&mut self, _ctx: &InterpolationAlignmentClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolation_format_clause(&mut self, _ctx: &InterpolationFormatClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolation_format_clause(&mut self, _ctx: &InterpolationFormatClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_multi_line_raw_string_start_token(&mut self, _ctx: &InterpolatedMultiLineRawStringStartTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_multi_line_raw_string_start_token(&mut self, _ctx: &InterpolatedMultiLineRawStringStartTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_raw_string_end_token(&mut self, _ctx: &InterpolatedRawStringEndTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_raw_string_end_token(&mut self, _ctx: &InterpolatedRawStringEndTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_single_line_raw_string_start_token(&mut self, _ctx: &InterpolatedSingleLineRawStringStartTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_single_line_raw_string_start_token(&mut self, _ctx: &InterpolatedSingleLineRawStringStartTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_literal_expression(&mut self, _ctx: &LiteralExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_literal_expression(&mut self, _ctx: &LiteralExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_utf8_multi_line_raw_string_literal_token(&mut self, _ctx: &Utf8MultiLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_utf8_multi_line_raw_string_literal_token(&mut self, _ctx: &Utf8MultiLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_utf8_single_line_raw_string_literal_token(&mut self, _ctx: &Utf8SingleLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_utf8_single_line_raw_string_literal_token(&mut self, _ctx: &Utf8SingleLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_utf8_string_literal_token(&mut self, _ctx: &Utf8StringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_utf8_string_literal_token(&mut self, _ctx: &Utf8StringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_make_ref_expression(&mut self, _ctx: &MakeRefExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_make_ref_expression(&mut self, _ctx: &MakeRefExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_member_binding_expression(&mut self, _ctx: &MemberBindingExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_member_binding_expression(&mut self, _ctx: &MemberBindingExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_expression(&mut self, _ctx: &ParenthesizedExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_expression(&mut self, _ctx: &ParenthesizedExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_prefix_unary_expression(&mut self, _ctx: &PrefixUnaryExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_prefix_unary_expression(&mut self, _ctx: &PrefixUnaryExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_query_expression(&mut self, _ctx: &QueryExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_query_expression(&mut self, _ctx: &QueryExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_from_clause(&mut self, _ctx: &FromClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_from_clause(&mut self, _ctx: &FromClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_query_body(&mut self, _ctx: &QueryBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_query_body(&mut self, _ctx: &QueryBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_query_clause(&mut self, _ctx: &QueryClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_query_clause(&mut self, _ctx: &QueryClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_join_clause(&mut self, _ctx: &JoinClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_join_clause(&mut self, _ctx: &JoinClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_join_into_clause(&mut self, _ctx: &JoinIntoClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_join_into_clause(&mut self, _ctx: &JoinIntoClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_let_clause(&mut self, _ctx: &LetClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_let_clause(&mut self, _ctx: &LetClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_order_by_clause(&mut self, _ctx: &OrderByClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_order_by_clause(&mut self, _ctx: &OrderByClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_ordering(&mut self, _ctx: &OrderingContext) -> Result<(), E> { Ok(()) }
    fn exit_ordering(&mut self, _ctx: &OrderingContext) -> Result<(), E> { Ok(()) }
    fn enter_where_clause(&mut self, _ctx: &WhereClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_where_clause(&mut self, _ctx: &WhereClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_select_or_group_clause(&mut self, _ctx: &SelectOrGroupClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_select_or_group_clause(&mut self, _ctx: &SelectOrGroupClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_group_clause(&mut self, _ctx: &GroupClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_group_clause(&mut self, _ctx: &GroupClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_select_clause(&mut self, _ctx: &SelectClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_select_clause(&mut self, _ctx: &SelectClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_query_continuation(&mut self, _ctx: &QueryContinuationContext) -> Result<(), E> { Ok(()) }
    fn exit_query_continuation(&mut self, _ctx: &QueryContinuationContext) -> Result<(), E> { Ok(()) }
    fn enter_ref_expression(&mut self, _ctx: &RefExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_ref_expression(&mut self, _ctx: &RefExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_ref_type_expression(&mut self, _ctx: &RefTypeExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_ref_type_expression(&mut self, _ctx: &RefTypeExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_ref_value_expression(&mut self, _ctx: &RefValueExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_ref_value_expression(&mut self, _ctx: &RefValueExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_size_of_expression(&mut self, _ctx: &SizeOfExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_size_of_expression(&mut self, _ctx: &SizeOfExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_stack_alloc_array_creation_expression(&mut self, _ctx: &StackAllocArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_stack_alloc_array_creation_expression(&mut self, _ctx: &StackAllocArrayCreationExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_expression_arm(&mut self, _ctx: &SwitchExpressionArmContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_expression_arm(&mut self, _ctx: &SwitchExpressionArmContext) -> Result<(), E> { Ok(()) }
    fn enter_throw_expression(&mut self, _ctx: &ThrowExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_throw_expression(&mut self, _ctx: &ThrowExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_tuple_expression(&mut self, _ctx: &TupleExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_tuple_expression(&mut self, _ctx: &TupleExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_type_of_expression(&mut self, _ctx: &TypeOfExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_type_of_expression(&mut self, _ctx: &TypeOfExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_unsafe_expression(&mut self, _ctx: &UnsafeExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_unsafe_expression(&mut self, _ctx: &UnsafeExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_syntax_token(&mut self, _ctx: &SyntaxTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_syntax_token(&mut self, _ctx: &SyntaxTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_identifier_token(&mut self, _ctx: &IdentifierTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_identifier_token(&mut self, _ctx: &IdentifierTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_keyword(&mut self, _ctx: &KeywordContext) -> Result<(), E> { Ok(()) }
    fn exit_keyword(&mut self, _ctx: &KeywordContext) -> Result<(), E> { Ok(()) }
    fn enter_numeric_literal_token(&mut self, _ctx: &NumericLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_numeric_literal_token(&mut self, _ctx: &NumericLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_integer_literal_token(&mut self, _ctx: &IntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_integer_literal_token(&mut self, _ctx: &IntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_decimal_integer_literal_token(&mut self, _ctx: &DecimalIntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_decimal_integer_literal_token(&mut self, _ctx: &DecimalIntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_hexadecimal_integer_literal_token(&mut self, _ctx: &HexadecimalIntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_hexadecimal_integer_literal_token(&mut self, _ctx: &HexadecimalIntegerLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_real_literal_token(&mut self, _ctx: &RealLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_real_literal_token(&mut self, _ctx: &RealLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_character_literal_token(&mut self, _ctx: &CharacterLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_character_literal_token(&mut self, _ctx: &CharacterLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_string_literal_token(&mut self, _ctx: &StringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_string_literal_token(&mut self, _ctx: &StringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_regular_string_literal_token(&mut self, _ctx: &RegularStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_regular_string_literal_token(&mut self, _ctx: &RegularStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_verbatim_string_literal_token(&mut self, _ctx: &VerbatimStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_verbatim_string_literal_token(&mut self, _ctx: &VerbatimStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_operator_token(&mut self, _ctx: &OperatorTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_operator_token(&mut self, _ctx: &OperatorTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_punctuation_token(&mut self, _ctx: &PunctuationTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_punctuation_token(&mut self, _ctx: &PunctuationTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_text_token(&mut self, _ctx: &InterpolatedStringTextTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_text_token(&mut self, _ctx: &InterpolatedStringTextTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_multi_line_raw_string_literal_token(&mut self, _ctx: &MultiLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_multi_line_raw_string_literal_token(&mut self, _ctx: &MultiLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_single_line_raw_string_literal_token(&mut self, _ctx: &SingleLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn exit_single_line_raw_string_literal_token(&mut self, _ctx: &SingleLineRawStringLiteralTokenContext) -> Result<(), E> { Ok(()) }
    fn enter_record_keyword(&mut self, _ctx: &RecordKeywordContext) -> Result<(), E> { Ok(()) }
    fn exit_record_keyword(&mut self, _ctx: &RecordKeywordContext) -> Result<(), E> { Ok(()) }
    fn enter_right_shift(&mut self, _ctx: &RightShiftContext) -> Result<(), E> { Ok(()) }
    fn exit_right_shift(&mut self, _ctx: &RightShiftContext) -> Result<(), E> { Ok(()) }
    fn enter_unsigned_right_shift(&mut self, _ctx: &UnsignedRightShiftContext) -> Result<(), E> { Ok(()) }
    fn exit_unsigned_right_shift(&mut self, _ctx: &UnsignedRightShiftContext) -> Result<(), E> { Ok(()) }
    fn enter_right_shift_assignment(&mut self, _ctx: &RightShiftAssignmentContext) -> Result<(), E> { Ok(()) }
    fn exit_right_shift_assignment(&mut self, _ctx: &RightShiftAssignmentContext) -> Result<(), E> { Ok(()) }
    fn enter_unsigned_right_shift_assignment(&mut self, _ctx: &UnsignedRightShiftAssignmentContext) -> Result<(), E> { Ok(()) }
    fn exit_unsigned_right_shift_assignment(&mut self, _ctx: &UnsignedRightShiftAssignmentContext) -> Result<(), E> { Ok(()) }
    fn enter_local_variable_declaration(&mut self, _ctx: &LocalVariableDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_local_variable_declaration(&mut self, _ctx: &LocalVariableDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_local_variable_declarator(&mut self, _ctx: &LocalVariableDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn exit_local_variable_declarator(&mut self, _ctx: &LocalVariableDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn visit_terminal(&mut self, _node: &TerminalNode) -> Result<(), E> { Ok(()) }
    fn visit_error_node(&mut self, _node: &ErrorNode) -> Result<(), E> { Ok(()) }
    fn output(&mut self) -> std::io::Stdout { std::io::stdout() }
}

#[allow(dead_code)]
pub struct CSharpTreeWalker;

#[allow(dead_code)]
impl CSharpTreeWalker {
    pub fn walk<E, T: CSharpListener<E>>(
        listener: &mut T,
        tree: antlr4_runtime::Node<'_>,
    ) -> Result<(), E> {
        Self::__walk(listener, tree, None)
    }

    pub fn walk_with_invocation_states<E, T: CSharpListener<E>>(
        listener: &mut T,
        tree: antlr4_runtime::Node<'_>,
        parent_invocation_states: Vec<isize>,
    ) -> Result<(), E> {
        Self::__walk(listener, tree, Some(parent_invocation_states))
    }

    fn __walk<E, T: CSharpListener<E>>(
        listener: &mut T,
        tree: antlr4_runtime::Node<'_>,
        mut invocation_states: Option<Vec<isize>>,
    ) -> Result<(), E> {
        enum Event<'tree> {
            Enter(antlr4_runtime::Node<'tree>),
            Exit(RuleNodeView<'tree>),
        }

        let mut stack = vec![Event::Enter(tree)];
        while let Some(event) = stack.pop() {
            match event {
                Event::Enter(node) => match node.kind() {
                    antlr4_runtime::NodeKind::Rule => {
                        let context = node.as_rule().expect("rule node kind checked");
                        if let Some(states) = &mut invocation_states {
                            states.insert(0, context.invoking_state());
                        }
                        listener.enter_every_rule(context)?;
                        match __context_kind(context) {
                        0 => listener.enter_compilation_unit(&CompilationUnitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        1 => listener.enter_extern_alias_directive(&ExternAliasDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_using_directive(&UsingDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_name_equals(&NameEqualsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_identifier_name(&IdentifierNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_attribute_list(&AttributeListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_attribute_target_specifier(&AttributeTargetSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_attribute(&AttributeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_name(&NameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_alias_qualified_name(&AliasQualifiedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_simple_name(&SimpleNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_generic_name(&GenericNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_type_argument_list(&TypeArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_attribute_argument_list(&AttributeArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_attribute_argument(&AttributeArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_name_colon(&NameColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_member_declaration(&MemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_base_field_declaration(&BaseFieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_event_field_declaration(&EventFieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_modifier(&ModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_variable_declaration(&VariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_variable_declarator(&VariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_bracketed_argument_list(&BracketedArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_argument(&ArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_equals_value_clause(&EqualsValueClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_field_declaration(&FieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_base_method_declaration(&BaseMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_constructor_declaration(&ConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_parameter_list(&ParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_parameter(&ParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_constructor_initializer(&ConstructorInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_argument_list(&ArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_arrow_expression_clause(&ArrowExpressionClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_conversion_operator_declaration(&ConversionOperatorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_explicit_interface_specifier(&ExplicitInterfaceSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_destructor_declaration(&DestructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_method_declaration(&MethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_type_parameter_list(&TypeParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_type_parameter(&TypeParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_type_parameter_constraint_clause(&TypeParameterConstraintClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_type_parameter_constraint(&TypeParameterConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_allows_constraint_clause(&AllowsConstraintClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_allows_constraint(&AllowsConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_ref_struct_constraint(&RefStructConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_class_or_struct_constraint(&ClassOrStructConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_constructor_constraint(&ConstructorConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_default_constraint(&DefaultConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_type_constraint(&TypeConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_operator_declaration(&OperatorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_base_namespace_declaration(&BaseNamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_file_scoped_namespace_declaration(&FileScopedNamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_namespace_declaration(&NamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_base_property_declaration(&BasePropertyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_event_declaration(&EventDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_accessor_list(&AccessorListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_accessor_declaration(&AccessorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_indexer_declaration(&IndexerDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_bracketed_parameter_list(&BracketedParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_property_declaration(&PropertyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_base_type_declaration(&BaseTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_enum_declaration(&EnumDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_base_list(&BaseListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_base_type(&BaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_primary_constructor_base_type(&PrimaryConstructorBaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_simple_base_type(&SimpleBaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_enum_member_declaration(&EnumMemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        67 => listener.enter_type_declaration(&TypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        68 => listener.enter_class_declaration(&ClassDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        69 => listener.enter_extension_block_declaration(&ExtensionBlockDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        70 => listener.enter_interface_declaration(&InterfaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        71 => listener.enter_record_declaration(&RecordDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        72 => listener.enter_struct_declaration(&StructDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        73 => listener.enter_union_declaration(&UnionDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        74 => listener.enter_delegate_declaration(&DelegateDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        75 => listener.enter_global_statement(&GlobalStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        76 => listener.enter_type(&TypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        77 => listener.enter_array_type(&ArrayTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        78 => listener.enter_array_rank_specifier(&ArrayRankSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        79 => listener.enter_function_pointer_type(&FunctionPointerTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        80 => listener.enter_function_pointer_calling_convention(&FunctionPointerCallingConventionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        81 => listener.enter_function_pointer_unmanaged_calling_convention_list(&FunctionPointerUnmanagedCallingConventionListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        82 => listener.enter_function_pointer_unmanaged_calling_convention(&FunctionPointerUnmanagedCallingConventionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        83 => listener.enter_function_pointer_parameter_list(&FunctionPointerParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        84 => listener.enter_function_pointer_parameter(&FunctionPointerParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        85 => listener.enter_predefined_type(&PredefinedTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        86 => listener.enter_ref_type(&RefTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        87 => listener.enter_scoped_type(&ScopedTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        88 => listener.enter_tuple_type(&TupleTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        89 => listener.enter_tuple_element(&TupleElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        90 => listener.enter_statement(&StatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        91 => listener.enter_break_statement(&BreakStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        92 => listener.enter_checked_statement(&CheckedStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        93 => listener.enter_common_for_each_statement(&CommonForEachStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        94 => listener.enter_for_each_statement(&ForEachStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        95 => listener.enter_for_each_variable_statement(&ForEachVariableStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        96 => listener.enter_continue_statement(&ContinueStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        97 => listener.enter_do_statement(&DoStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        98 => listener.enter_empty_statement(&EmptyStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        99 => listener.enter_expression_statement(&ExpressionStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        100 => listener.enter_fixed_statement(&FixedStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        101 => listener.enter_for_statement(&ForStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        102 => listener.enter_goto_statement(&GotoStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        103 => listener.enter_if_statement(&IfStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        104 => listener.enter_else_clause(&ElseClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        105 => listener.enter_labeled_statement(&LabeledStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        106 => listener.enter_local_declaration_statement(&LocalDeclarationStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        107 => listener.enter_local_function_statement(&LocalFunctionStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        108 => listener.enter_lock_statement(&LockStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        109 => listener.enter_return_statement(&ReturnStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        110 => listener.enter_switch_statement(&SwitchStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        111 => listener.enter_switch_section(&SwitchSectionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        112 => listener.enter_switch_label(&SwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        113 => listener.enter_case_pattern_switch_label(&CasePatternSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        114 => listener.enter_pattern(&PatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        115 => listener.enter_constant_pattern(&ConstantPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        116 => listener.enter_declaration_pattern(&DeclarationPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        117 => listener.enter_variable_designation(&VariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        118 => listener.enter_discard_designation(&DiscardDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        119 => listener.enter_parenthesized_variable_designation(&ParenthesizedVariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        120 => listener.enter_single_variable_designation(&SingleVariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        121 => listener.enter_discard_pattern(&DiscardPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        122 => listener.enter_list_pattern(&ListPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        123 => listener.enter_parenthesized_pattern(&ParenthesizedPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        124 => listener.enter_recursive_pattern(&RecursivePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        125 => listener.enter_positional_pattern_clause(&PositionalPatternClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        126 => listener.enter_subpattern(&SubpatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        127 => listener.enter_base_expression_colon(&BaseExpressionColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        128 => listener.enter_expression_colon(&ExpressionColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        129 => listener.enter_property_pattern_clause(&PropertyPatternClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        130 => listener.enter_relational_pattern(&RelationalPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        131 => listener.enter_slice_pattern(&SlicePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        132 => listener.enter_type_pattern(&TypePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        133 => listener.enter_unary_pattern(&UnaryPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        134 => listener.enter_var_pattern(&VarPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        135 => listener.enter_when_clause(&WhenClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        136 => listener.enter_case_switch_label(&CaseSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        137 => listener.enter_default_switch_label(&DefaultSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        138 => listener.enter_throw_statement(&ThrowStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        139 => listener.enter_try_statement(&TryStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        140 => listener.enter_catch_clause(&CatchClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        141 => listener.enter_catch_declaration(&CatchDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        142 => listener.enter_catch_filter_clause(&CatchFilterClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        143 => listener.enter_finally_clause(&FinallyClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        144 => listener.enter_unsafe_statement(&UnsafeStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        145 => listener.enter_using_statement(&UsingStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        146 => listener.enter_while_statement(&WhileStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        147 => listener.enter_yield_statement(&YieldStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        148 => listener.enter_expression(&ExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        149 => listener.enter_anonymous_function_expression(&AnonymousFunctionExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        150 => listener.enter_anonymous_method_expression(&AnonymousMethodExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        151 => listener.enter_lambda_expression(&LambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        152 => listener.enter_parenthesized_lambda_expression(&ParenthesizedLambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        153 => listener.enter_simple_lambda_expression(&SimpleLambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        154 => listener.enter_anonymous_object_creation_expression(&AnonymousObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        155 => listener.enter_anonymous_object_member_declarator(&AnonymousObjectMemberDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        156 => listener.enter_array_creation_expression(&ArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        157 => listener.enter_initializer_expression(&InitializerExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        158 => listener.enter_await_expression(&AwaitExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        159 => listener.enter_base_object_creation_expression(&BaseObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        160 => listener.enter_implicit_object_creation_expression(&ImplicitObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        161 => listener.enter_object_creation_expression(&ObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        162 => listener.enter_cast_expression(&CastExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        163 => listener.enter_checked_expression(&CheckedExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        164 => listener.enter_collection_expression(&CollectionExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        165 => listener.enter_collection_element(&CollectionElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        166 => listener.enter_expression_element(&ExpressionElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        167 => listener.enter_spread_element(&SpreadElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        168 => listener.enter_with_element(&WithElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        169 => listener.enter_declaration_expression(&DeclarationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        170 => listener.enter_default_expression(&DefaultExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        171 => listener.enter_element_binding_expression(&ElementBindingExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        172 => listener.enter_field_expression(&FieldExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        173 => listener.enter_implicit_array_creation_expression(&ImplicitArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        174 => listener.enter_implicit_element_access(&ImplicitElementAccessContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        175 => listener.enter_implicit_stack_alloc_array_creation_expression(&ImplicitStackAllocArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        176 => listener.enter_instance_expression(&InstanceExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        177 => listener.enter_base_expression(&BaseExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        178 => listener.enter_this_expression(&ThisExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        179 => listener.enter_interpolated_string_expression(&InterpolatedStringExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        180 => listener.enter_interpolated_string_content(&InterpolatedStringContentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        181 => listener.enter_interpolated_string_text(&InterpolatedStringTextContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        182 => listener.enter_interpolation(&InterpolationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        183 => listener.enter_interpolation_alignment_clause(&InterpolationAlignmentClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        184 => listener.enter_interpolation_format_clause(&InterpolationFormatClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        185 => listener.enter_interpolated_multi_line_raw_string_start_token(&InterpolatedMultiLineRawStringStartTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        186 => listener.enter_interpolated_raw_string_end_token(&InterpolatedRawStringEndTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        187 => listener.enter_interpolated_single_line_raw_string_start_token(&InterpolatedSingleLineRawStringStartTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        188 => listener.enter_literal_expression(&LiteralExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        189 => listener.enter_utf8_multi_line_raw_string_literal_token(&Utf8MultiLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        190 => listener.enter_utf8_single_line_raw_string_literal_token(&Utf8SingleLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        191 => listener.enter_utf8_string_literal_token(&Utf8StringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        192 => listener.enter_make_ref_expression(&MakeRefExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        193 => listener.enter_member_binding_expression(&MemberBindingExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        194 => listener.enter_parenthesized_expression(&ParenthesizedExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        195 => listener.enter_prefix_unary_expression(&PrefixUnaryExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        196 => listener.enter_query_expression(&QueryExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        197 => listener.enter_from_clause(&FromClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        198 => listener.enter_query_body(&QueryBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        199 => listener.enter_query_clause(&QueryClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        200 => listener.enter_join_clause(&JoinClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        201 => listener.enter_join_into_clause(&JoinIntoClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        202 => listener.enter_let_clause(&LetClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        203 => listener.enter_order_by_clause(&OrderByClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        204 => listener.enter_ordering(&OrderingContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        205 => listener.enter_where_clause(&WhereClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        206 => listener.enter_select_or_group_clause(&SelectOrGroupClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        207 => listener.enter_group_clause(&GroupClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        208 => listener.enter_select_clause(&SelectClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        209 => listener.enter_query_continuation(&QueryContinuationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        210 => listener.enter_ref_expression(&RefExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        211 => listener.enter_ref_type_expression(&RefTypeExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        212 => listener.enter_ref_value_expression(&RefValueExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        213 => listener.enter_size_of_expression(&SizeOfExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        214 => listener.enter_stack_alloc_array_creation_expression(&StackAllocArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        215 => listener.enter_switch_expression_arm(&SwitchExpressionArmContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        216 => listener.enter_throw_expression(&ThrowExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        217 => listener.enter_tuple_expression(&TupleExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        218 => listener.enter_type_of_expression(&TypeOfExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        219 => listener.enter_unsafe_expression(&UnsafeExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        220 => listener.enter_syntax_token(&SyntaxTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        221 => listener.enter_identifier_token(&IdentifierTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        222 => listener.enter_keyword(&KeywordContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        223 => listener.enter_numeric_literal_token(&NumericLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        224 => listener.enter_integer_literal_token(&IntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        225 => listener.enter_decimal_integer_literal_token(&DecimalIntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        226 => listener.enter_hexadecimal_integer_literal_token(&HexadecimalIntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        227 => listener.enter_real_literal_token(&RealLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        228 => listener.enter_character_literal_token(&CharacterLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        229 => listener.enter_string_literal_token(&StringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        230 => listener.enter_regular_string_literal_token(&RegularStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        231 => listener.enter_verbatim_string_literal_token(&VerbatimStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        232 => listener.enter_operator_token(&OperatorTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        233 => listener.enter_punctuation_token(&PunctuationTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        234 => listener.enter_interpolated_string_text_token(&InterpolatedStringTextTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        235 => listener.enter_multi_line_raw_string_literal_token(&MultiLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        236 => listener.enter_single_line_raw_string_literal_token(&SingleLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        237 => listener.enter_record_keyword(&RecordKeywordContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        238 => listener.enter_right_shift(&RightShiftContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        239 => listener.enter_unsigned_right_shift(&UnsignedRightShiftContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        240 => listener.enter_right_shift_assignment(&RightShiftAssignmentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        241 => listener.enter_unsigned_right_shift_assignment(&UnsignedRightShiftAssignmentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        242 => listener.enter_local_variable_declaration(&LocalVariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        243 => listener.enter_local_variable_declarator(&LocalVariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                            _ => {}
                        }
                        stack.push(Event::Exit(context));
                        stack.extend(context.children().rev().map(Event::Enter));
                    }
                    antlr4_runtime::NodeKind::Terminal => {
                        listener.visit_terminal(&TerminalNode::new(
                            node.as_terminal().expect("terminal node kind checked"),
                        ))?;
                    }
                    antlr4_runtime::NodeKind::Error => {
                        listener.visit_error_node(&ErrorNode::new(
                            node.as_error().expect("error node kind checked"),
                        ))?;
                    }
                },
                Event::Exit(context) => {
                    match __context_kind(context) {
                    0 => listener.exit_compilation_unit(&CompilationUnitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    1 => listener.exit_extern_alias_directive(&ExternAliasDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_using_directive(&UsingDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_name_equals(&NameEqualsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_identifier_name(&IdentifierNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_attribute_list(&AttributeListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_attribute_target_specifier(&AttributeTargetSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_attribute(&AttributeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_name(&NameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_alias_qualified_name(&AliasQualifiedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_simple_name(&SimpleNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_generic_name(&GenericNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_type_argument_list(&TypeArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_attribute_argument_list(&AttributeArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_attribute_argument(&AttributeArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_name_colon(&NameColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_member_declaration(&MemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_base_field_declaration(&BaseFieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_event_field_declaration(&EventFieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_modifier(&ModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_variable_declaration(&VariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_variable_declarator(&VariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_bracketed_argument_list(&BracketedArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_argument(&ArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_equals_value_clause(&EqualsValueClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_field_declaration(&FieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_base_method_declaration(&BaseMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_constructor_declaration(&ConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_parameter_list(&ParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_parameter(&ParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_constructor_initializer(&ConstructorInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_argument_list(&ArgumentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_arrow_expression_clause(&ArrowExpressionClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_conversion_operator_declaration(&ConversionOperatorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_explicit_interface_specifier(&ExplicitInterfaceSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_destructor_declaration(&DestructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_method_declaration(&MethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_type_parameter_list(&TypeParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_type_parameter(&TypeParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_type_parameter_constraint_clause(&TypeParameterConstraintClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_type_parameter_constraint(&TypeParameterConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_allows_constraint_clause(&AllowsConstraintClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_allows_constraint(&AllowsConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_ref_struct_constraint(&RefStructConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_class_or_struct_constraint(&ClassOrStructConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_constructor_constraint(&ConstructorConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_default_constraint(&DefaultConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_type_constraint(&TypeConstraintContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_operator_declaration(&OperatorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_base_namespace_declaration(&BaseNamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_file_scoped_namespace_declaration(&FileScopedNamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_namespace_declaration(&NamespaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_base_property_declaration(&BasePropertyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_event_declaration(&EventDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_accessor_list(&AccessorListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_accessor_declaration(&AccessorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_indexer_declaration(&IndexerDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_bracketed_parameter_list(&BracketedParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_property_declaration(&PropertyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_base_type_declaration(&BaseTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_enum_declaration(&EnumDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_base_list(&BaseListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_base_type(&BaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_primary_constructor_base_type(&PrimaryConstructorBaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_simple_base_type(&SimpleBaseTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_enum_member_declaration(&EnumMemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    67 => listener.exit_type_declaration(&TypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    68 => listener.exit_class_declaration(&ClassDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    69 => listener.exit_extension_block_declaration(&ExtensionBlockDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    70 => listener.exit_interface_declaration(&InterfaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    71 => listener.exit_record_declaration(&RecordDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    72 => listener.exit_struct_declaration(&StructDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    73 => listener.exit_union_declaration(&UnionDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    74 => listener.exit_delegate_declaration(&DelegateDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    75 => listener.exit_global_statement(&GlobalStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    76 => listener.exit_type(&TypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    77 => listener.exit_array_type(&ArrayTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    78 => listener.exit_array_rank_specifier(&ArrayRankSpecifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    79 => listener.exit_function_pointer_type(&FunctionPointerTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    80 => listener.exit_function_pointer_calling_convention(&FunctionPointerCallingConventionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    81 => listener.exit_function_pointer_unmanaged_calling_convention_list(&FunctionPointerUnmanagedCallingConventionListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    82 => listener.exit_function_pointer_unmanaged_calling_convention(&FunctionPointerUnmanagedCallingConventionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    83 => listener.exit_function_pointer_parameter_list(&FunctionPointerParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    84 => listener.exit_function_pointer_parameter(&FunctionPointerParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    85 => listener.exit_predefined_type(&PredefinedTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    86 => listener.exit_ref_type(&RefTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    87 => listener.exit_scoped_type(&ScopedTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    88 => listener.exit_tuple_type(&TupleTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    89 => listener.exit_tuple_element(&TupleElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    90 => listener.exit_statement(&StatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    91 => listener.exit_break_statement(&BreakStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    92 => listener.exit_checked_statement(&CheckedStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    93 => listener.exit_common_for_each_statement(&CommonForEachStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    94 => listener.exit_for_each_statement(&ForEachStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    95 => listener.exit_for_each_variable_statement(&ForEachVariableStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    96 => listener.exit_continue_statement(&ContinueStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    97 => listener.exit_do_statement(&DoStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    98 => listener.exit_empty_statement(&EmptyStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    99 => listener.exit_expression_statement(&ExpressionStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    100 => listener.exit_fixed_statement(&FixedStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    101 => listener.exit_for_statement(&ForStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    102 => listener.exit_goto_statement(&GotoStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    103 => listener.exit_if_statement(&IfStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    104 => listener.exit_else_clause(&ElseClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    105 => listener.exit_labeled_statement(&LabeledStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    106 => listener.exit_local_declaration_statement(&LocalDeclarationStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    107 => listener.exit_local_function_statement(&LocalFunctionStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    108 => listener.exit_lock_statement(&LockStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    109 => listener.exit_return_statement(&ReturnStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    110 => listener.exit_switch_statement(&SwitchStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    111 => listener.exit_switch_section(&SwitchSectionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    112 => listener.exit_switch_label(&SwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    113 => listener.exit_case_pattern_switch_label(&CasePatternSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    114 => listener.exit_pattern(&PatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    115 => listener.exit_constant_pattern(&ConstantPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    116 => listener.exit_declaration_pattern(&DeclarationPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    117 => listener.exit_variable_designation(&VariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    118 => listener.exit_discard_designation(&DiscardDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    119 => listener.exit_parenthesized_variable_designation(&ParenthesizedVariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    120 => listener.exit_single_variable_designation(&SingleVariableDesignationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    121 => listener.exit_discard_pattern(&DiscardPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    122 => listener.exit_list_pattern(&ListPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    123 => listener.exit_parenthesized_pattern(&ParenthesizedPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    124 => listener.exit_recursive_pattern(&RecursivePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    125 => listener.exit_positional_pattern_clause(&PositionalPatternClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    126 => listener.exit_subpattern(&SubpatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    127 => listener.exit_base_expression_colon(&BaseExpressionColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    128 => listener.exit_expression_colon(&ExpressionColonContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    129 => listener.exit_property_pattern_clause(&PropertyPatternClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    130 => listener.exit_relational_pattern(&RelationalPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    131 => listener.exit_slice_pattern(&SlicePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    132 => listener.exit_type_pattern(&TypePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    133 => listener.exit_unary_pattern(&UnaryPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    134 => listener.exit_var_pattern(&VarPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    135 => listener.exit_when_clause(&WhenClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    136 => listener.exit_case_switch_label(&CaseSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    137 => listener.exit_default_switch_label(&DefaultSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    138 => listener.exit_throw_statement(&ThrowStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    139 => listener.exit_try_statement(&TryStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    140 => listener.exit_catch_clause(&CatchClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    141 => listener.exit_catch_declaration(&CatchDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    142 => listener.exit_catch_filter_clause(&CatchFilterClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    143 => listener.exit_finally_clause(&FinallyClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    144 => listener.exit_unsafe_statement(&UnsafeStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    145 => listener.exit_using_statement(&UsingStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    146 => listener.exit_while_statement(&WhileStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    147 => listener.exit_yield_statement(&YieldStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    148 => listener.exit_expression(&ExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    149 => listener.exit_anonymous_function_expression(&AnonymousFunctionExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    150 => listener.exit_anonymous_method_expression(&AnonymousMethodExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    151 => listener.exit_lambda_expression(&LambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    152 => listener.exit_parenthesized_lambda_expression(&ParenthesizedLambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    153 => listener.exit_simple_lambda_expression(&SimpleLambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    154 => listener.exit_anonymous_object_creation_expression(&AnonymousObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    155 => listener.exit_anonymous_object_member_declarator(&AnonymousObjectMemberDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    156 => listener.exit_array_creation_expression(&ArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    157 => listener.exit_initializer_expression(&InitializerExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    158 => listener.exit_await_expression(&AwaitExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    159 => listener.exit_base_object_creation_expression(&BaseObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    160 => listener.exit_implicit_object_creation_expression(&ImplicitObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    161 => listener.exit_object_creation_expression(&ObjectCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    162 => listener.exit_cast_expression(&CastExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    163 => listener.exit_checked_expression(&CheckedExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    164 => listener.exit_collection_expression(&CollectionExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    165 => listener.exit_collection_element(&CollectionElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    166 => listener.exit_expression_element(&ExpressionElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    167 => listener.exit_spread_element(&SpreadElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    168 => listener.exit_with_element(&WithElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    169 => listener.exit_declaration_expression(&DeclarationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    170 => listener.exit_default_expression(&DefaultExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    171 => listener.exit_element_binding_expression(&ElementBindingExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    172 => listener.exit_field_expression(&FieldExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    173 => listener.exit_implicit_array_creation_expression(&ImplicitArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    174 => listener.exit_implicit_element_access(&ImplicitElementAccessContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    175 => listener.exit_implicit_stack_alloc_array_creation_expression(&ImplicitStackAllocArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    176 => listener.exit_instance_expression(&InstanceExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    177 => listener.exit_base_expression(&BaseExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    178 => listener.exit_this_expression(&ThisExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    179 => listener.exit_interpolated_string_expression(&InterpolatedStringExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    180 => listener.exit_interpolated_string_content(&InterpolatedStringContentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    181 => listener.exit_interpolated_string_text(&InterpolatedStringTextContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    182 => listener.exit_interpolation(&InterpolationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    183 => listener.exit_interpolation_alignment_clause(&InterpolationAlignmentClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    184 => listener.exit_interpolation_format_clause(&InterpolationFormatClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    185 => listener.exit_interpolated_multi_line_raw_string_start_token(&InterpolatedMultiLineRawStringStartTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    186 => listener.exit_interpolated_raw_string_end_token(&InterpolatedRawStringEndTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    187 => listener.exit_interpolated_single_line_raw_string_start_token(&InterpolatedSingleLineRawStringStartTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    188 => listener.exit_literal_expression(&LiteralExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    189 => listener.exit_utf8_multi_line_raw_string_literal_token(&Utf8MultiLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    190 => listener.exit_utf8_single_line_raw_string_literal_token(&Utf8SingleLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    191 => listener.exit_utf8_string_literal_token(&Utf8StringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    192 => listener.exit_make_ref_expression(&MakeRefExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    193 => listener.exit_member_binding_expression(&MemberBindingExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    194 => listener.exit_parenthesized_expression(&ParenthesizedExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    195 => listener.exit_prefix_unary_expression(&PrefixUnaryExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    196 => listener.exit_query_expression(&QueryExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    197 => listener.exit_from_clause(&FromClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    198 => listener.exit_query_body(&QueryBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    199 => listener.exit_query_clause(&QueryClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    200 => listener.exit_join_clause(&JoinClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    201 => listener.exit_join_into_clause(&JoinIntoClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    202 => listener.exit_let_clause(&LetClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    203 => listener.exit_order_by_clause(&OrderByClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    204 => listener.exit_ordering(&OrderingContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    205 => listener.exit_where_clause(&WhereClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    206 => listener.exit_select_or_group_clause(&SelectOrGroupClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    207 => listener.exit_group_clause(&GroupClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    208 => listener.exit_select_clause(&SelectClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    209 => listener.exit_query_continuation(&QueryContinuationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    210 => listener.exit_ref_expression(&RefExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    211 => listener.exit_ref_type_expression(&RefTypeExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    212 => listener.exit_ref_value_expression(&RefValueExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    213 => listener.exit_size_of_expression(&SizeOfExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    214 => listener.exit_stack_alloc_array_creation_expression(&StackAllocArrayCreationExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    215 => listener.exit_switch_expression_arm(&SwitchExpressionArmContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    216 => listener.exit_throw_expression(&ThrowExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    217 => listener.exit_tuple_expression(&TupleExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    218 => listener.exit_type_of_expression(&TypeOfExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    219 => listener.exit_unsafe_expression(&UnsafeExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    220 => listener.exit_syntax_token(&SyntaxTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    221 => listener.exit_identifier_token(&IdentifierTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    222 => listener.exit_keyword(&KeywordContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    223 => listener.exit_numeric_literal_token(&NumericLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    224 => listener.exit_integer_literal_token(&IntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    225 => listener.exit_decimal_integer_literal_token(&DecimalIntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    226 => listener.exit_hexadecimal_integer_literal_token(&HexadecimalIntegerLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    227 => listener.exit_real_literal_token(&RealLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    228 => listener.exit_character_literal_token(&CharacterLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    229 => listener.exit_string_literal_token(&StringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    230 => listener.exit_regular_string_literal_token(&RegularStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    231 => listener.exit_verbatim_string_literal_token(&VerbatimStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    232 => listener.exit_operator_token(&OperatorTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    233 => listener.exit_punctuation_token(&PunctuationTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    234 => listener.exit_interpolated_string_text_token(&InterpolatedStringTextTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    235 => listener.exit_multi_line_raw_string_literal_token(&MultiLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    236 => listener.exit_single_line_raw_string_literal_token(&SingleLineRawStringLiteralTokenContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    237 => listener.exit_record_keyword(&RecordKeywordContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    238 => listener.exit_right_shift(&RightShiftContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    239 => listener.exit_unsigned_right_shift(&UnsignedRightShiftContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    240 => listener.exit_right_shift_assignment(&RightShiftAssignmentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    241 => listener.exit_unsigned_right_shift_assignment(&UnsignedRightShiftAssignmentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    242 => listener.exit_local_variable_declaration(&LocalVariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    243 => listener.exit_local_variable_declarator(&LocalVariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        _ => {}
                    }
                    listener.exit_every_rule(context)?;
                    if let Some(states) = &mut invocation_states {
                        states.remove(0);
                    }
                }
            }
        }
        Ok(())
    }
}

pub type ParseTreeWalker = CSharpTreeWalker;

#[allow(dead_code, unused_variables)]
pub trait CSharpValidatedListener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: ValidatedRuleNode<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        CSharpValidatedTreeWalker::walk(self, tree)
    }

    fn enter_every_rule(&mut self, _ctx: ValidatedRuleNode<'_>) -> Result<(), E> { Ok(()) }
    fn exit_every_rule(&mut self, _ctx: ValidatedRuleNode<'_>) -> Result<(), E> { Ok(()) }

    fn enter_compilation_unit(&mut self, _ctx: &CompilationUnitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_compilation_unit(&mut self, _ctx: &CompilationUnitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_extern_alias_directive(&mut self, _ctx: &ExternAliasDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_extern_alias_directive(&mut self, _ctx: &ExternAliasDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_using_directive(&mut self, _ctx: &UsingDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_using_directive(&mut self, _ctx: &UsingDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_name_equals(&mut self, _ctx: &NameEqualsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_name_equals(&mut self, _ctx: &NameEqualsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_identifier_name(&mut self, _ctx: &IdentifierNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_identifier_name(&mut self, _ctx: &IdentifierNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_attribute_list(&mut self, _ctx: &AttributeListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_attribute_list(&mut self, _ctx: &AttributeListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_attribute_target_specifier(&mut self, _ctx: &AttributeTargetSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_attribute_target_specifier(&mut self, _ctx: &AttributeTargetSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_attribute(&mut self, _ctx: &AttributeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_attribute(&mut self, _ctx: &AttributeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_name(&mut self, _ctx: &NameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_name(&mut self, _ctx: &NameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_alias_qualified_name(&mut self, _ctx: &AliasQualifiedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_alias_qualified_name(&mut self, _ctx: &AliasQualifiedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_simple_name(&mut self, _ctx: &SimpleNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_simple_name(&mut self, _ctx: &SimpleNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_generic_name(&mut self, _ctx: &GenericNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_generic_name(&mut self, _ctx: &GenericNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_argument_list(&mut self, _ctx: &TypeArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_argument_list(&mut self, _ctx: &TypeArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_attribute_argument_list(&mut self, _ctx: &AttributeArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_attribute_argument_list(&mut self, _ctx: &AttributeArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_attribute_argument(&mut self, _ctx: &AttributeArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_attribute_argument(&mut self, _ctx: &AttributeArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_name_colon(&mut self, _ctx: &NameColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_name_colon(&mut self, _ctx: &NameColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_member_declaration(&mut self, _ctx: &MemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_member_declaration(&mut self, _ctx: &MemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_field_declaration(&mut self, _ctx: &BaseFieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_field_declaration(&mut self, _ctx: &BaseFieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_event_field_declaration(&mut self, _ctx: &EventFieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_event_field_declaration(&mut self, _ctx: &EventFieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_modifier(&mut self, _ctx: &ModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_modifier(&mut self, _ctx: &ModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_declaration(&mut self, _ctx: &VariableDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_declaration(&mut self, _ctx: &VariableDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_declarator(&mut self, _ctx: &VariableDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarator(&mut self, _ctx: &VariableDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_bracketed_argument_list(&mut self, _ctx: &BracketedArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_bracketed_argument_list(&mut self, _ctx: &BracketedArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_argument(&mut self, _ctx: &ArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_argument(&mut self, _ctx: &ArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_equals_value_clause(&mut self, _ctx: &EqualsValueClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_equals_value_clause(&mut self, _ctx: &EqualsValueClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_field_declaration(&mut self, _ctx: &FieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_field_declaration(&mut self, _ctx: &FieldDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_method_declaration(&mut self, _ctx: &BaseMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_method_declaration(&mut self, _ctx: &BaseMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_constructor_declaration(&mut self, _ctx: &ConstructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_constructor_declaration(&mut self, _ctx: &ConstructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parameter_list(&mut self, _ctx: &ParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parameter_list(&mut self, _ctx: &ParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parameter(&mut self, _ctx: &ParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parameter(&mut self, _ctx: &ParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_constructor_initializer(&mut self, _ctx: &ConstructorInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_constructor_initializer(&mut self, _ctx: &ConstructorInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_argument_list(&mut self, _ctx: &ArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_argument_list(&mut self, _ctx: &ArgumentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_block(&mut self, _ctx: &BlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_block(&mut self, _ctx: &BlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_arrow_expression_clause(&mut self, _ctx: &ArrowExpressionClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_arrow_expression_clause(&mut self, _ctx: &ArrowExpressionClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_conversion_operator_declaration(&mut self, _ctx: &ConversionOperatorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_conversion_operator_declaration(&mut self, _ctx: &ConversionOperatorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_explicit_interface_specifier(&mut self, _ctx: &ExplicitInterfaceSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_explicit_interface_specifier(&mut self, _ctx: &ExplicitInterfaceSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_destructor_declaration(&mut self, _ctx: &DestructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_destructor_declaration(&mut self, _ctx: &DestructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_method_declaration(&mut self, _ctx: &MethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_declaration(&mut self, _ctx: &MethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_list(&mut self, _ctx: &TypeParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_list(&mut self, _ctx: &TypeParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter(&mut self, _ctx: &TypeParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter(&mut self, _ctx: &TypeParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_constraint_clause(&mut self, _ctx: &TypeParameterConstraintClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_constraint_clause(&mut self, _ctx: &TypeParameterConstraintClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_parameter_constraint(&mut self, _ctx: &TypeParameterConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_parameter_constraint(&mut self, _ctx: &TypeParameterConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_allows_constraint_clause(&mut self, _ctx: &AllowsConstraintClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_allows_constraint_clause(&mut self, _ctx: &AllowsConstraintClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_allows_constraint(&mut self, _ctx: &AllowsConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_allows_constraint(&mut self, _ctx: &AllowsConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ref_struct_constraint(&mut self, _ctx: &RefStructConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ref_struct_constraint(&mut self, _ctx: &RefStructConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_or_struct_constraint(&mut self, _ctx: &ClassOrStructConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_or_struct_constraint(&mut self, _ctx: &ClassOrStructConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_constructor_constraint(&mut self, _ctx: &ConstructorConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_constructor_constraint(&mut self, _ctx: &ConstructorConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_default_constraint(&mut self, _ctx: &DefaultConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_default_constraint(&mut self, _ctx: &DefaultConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_constraint(&mut self, _ctx: &TypeConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_constraint(&mut self, _ctx: &TypeConstraintContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_operator_declaration(&mut self, _ctx: &OperatorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_operator_declaration(&mut self, _ctx: &OperatorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_namespace_declaration(&mut self, _ctx: &BaseNamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_namespace_declaration(&mut self, _ctx: &BaseNamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_file_scoped_namespace_declaration(&mut self, _ctx: &FileScopedNamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_file_scoped_namespace_declaration(&mut self, _ctx: &FileScopedNamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_namespace_declaration(&mut self, _ctx: &NamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_namespace_declaration(&mut self, _ctx: &NamespaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_property_declaration(&mut self, _ctx: &BasePropertyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_property_declaration(&mut self, _ctx: &BasePropertyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_event_declaration(&mut self, _ctx: &EventDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_event_declaration(&mut self, _ctx: &EventDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_accessor_list(&mut self, _ctx: &AccessorListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_accessor_list(&mut self, _ctx: &AccessorListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_accessor_declaration(&mut self, _ctx: &AccessorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_accessor_declaration(&mut self, _ctx: &AccessorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_indexer_declaration(&mut self, _ctx: &IndexerDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_indexer_declaration(&mut self, _ctx: &IndexerDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_bracketed_parameter_list(&mut self, _ctx: &BracketedParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_bracketed_parameter_list(&mut self, _ctx: &BracketedParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_property_declaration(&mut self, _ctx: &PropertyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_property_declaration(&mut self, _ctx: &PropertyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_type_declaration(&mut self, _ctx: &BaseTypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_type_declaration(&mut self, _ctx: &BaseTypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_enum_declaration(&mut self, _ctx: &EnumDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enum_declaration(&mut self, _ctx: &EnumDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_list(&mut self, _ctx: &BaseListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_list(&mut self, _ctx: &BaseListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_type(&mut self, _ctx: &BaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_type(&mut self, _ctx: &BaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_primary_constructor_base_type(&mut self, _ctx: &PrimaryConstructorBaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_primary_constructor_base_type(&mut self, _ctx: &PrimaryConstructorBaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_simple_base_type(&mut self, _ctx: &SimpleBaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_simple_base_type(&mut self, _ctx: &SimpleBaseTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_enum_member_declaration(&mut self, _ctx: &EnumMemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enum_member_declaration(&mut self, _ctx: &EnumMemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_declaration(&mut self, _ctx: &TypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_declaration(&mut self, _ctx: &TypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_declaration(&mut self, _ctx: &ClassDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_declaration(&mut self, _ctx: &ClassDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_extension_block_declaration(&mut self, _ctx: &ExtensionBlockDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_extension_block_declaration(&mut self, _ctx: &ExtensionBlockDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_declaration(&mut self, _ctx: &InterfaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_declaration(&mut self, _ctx: &InterfaceDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_record_declaration(&mut self, _ctx: &RecordDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_declaration(&mut self, _ctx: &RecordDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_struct_declaration(&mut self, _ctx: &StructDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_struct_declaration(&mut self, _ctx: &StructDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_union_declaration(&mut self, _ctx: &UnionDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_union_declaration(&mut self, _ctx: &UnionDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_delegate_declaration(&mut self, _ctx: &DelegateDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_delegate_declaration(&mut self, _ctx: &DelegateDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_global_statement(&mut self, _ctx: &GlobalStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_global_statement(&mut self, _ctx: &GlobalStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type(&mut self, _ctx: &TypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type(&mut self, _ctx: &TypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_array_type(&mut self, _ctx: &ArrayTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_array_type(&mut self, _ctx: &ArrayTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_array_rank_specifier(&mut self, _ctx: &ArrayRankSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_array_rank_specifier(&mut self, _ctx: &ArrayRankSpecifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_type(&mut self, _ctx: &FunctionPointerTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_type(&mut self, _ctx: &FunctionPointerTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_calling_convention(&mut self, _ctx: &FunctionPointerCallingConventionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_calling_convention(&mut self, _ctx: &FunctionPointerCallingConventionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_unmanaged_calling_convention_list(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_unmanaged_calling_convention_list(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_unmanaged_calling_convention(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_unmanaged_calling_convention(&mut self, _ctx: &FunctionPointerUnmanagedCallingConventionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_parameter_list(&mut self, _ctx: &FunctionPointerParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_parameter_list(&mut self, _ctx: &FunctionPointerParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_function_pointer_parameter(&mut self, _ctx: &FunctionPointerParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_function_pointer_parameter(&mut self, _ctx: &FunctionPointerParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_predefined_type(&mut self, _ctx: &PredefinedTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_predefined_type(&mut self, _ctx: &PredefinedTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ref_type(&mut self, _ctx: &RefTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ref_type(&mut self, _ctx: &RefTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_scoped_type(&mut self, _ctx: &ScopedTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_scoped_type(&mut self, _ctx: &ScopedTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_tuple_type(&mut self, _ctx: &TupleTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_tuple_type(&mut self, _ctx: &TupleTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_tuple_element(&mut self, _ctx: &TupleElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_tuple_element(&mut self, _ctx: &TupleElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_statement(&mut self, _ctx: &StatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_statement(&mut self, _ctx: &StatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_break_statement(&mut self, _ctx: &BreakStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_break_statement(&mut self, _ctx: &BreakStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_checked_statement(&mut self, _ctx: &CheckedStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_checked_statement(&mut self, _ctx: &CheckedStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_common_for_each_statement(&mut self, _ctx: &CommonForEachStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_common_for_each_statement(&mut self, _ctx: &CommonForEachStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_for_each_statement(&mut self, _ctx: &ForEachStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_for_each_statement(&mut self, _ctx: &ForEachStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_for_each_variable_statement(&mut self, _ctx: &ForEachVariableStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_for_each_variable_statement(&mut self, _ctx: &ForEachVariableStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_continue_statement(&mut self, _ctx: &ContinueStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_continue_statement(&mut self, _ctx: &ContinueStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_do_statement(&mut self, _ctx: &DoStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_do_statement(&mut self, _ctx: &DoStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_empty_statement(&mut self, _ctx: &EmptyStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_empty_statement(&mut self, _ctx: &EmptyStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_statement(&mut self, _ctx: &ExpressionStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_statement(&mut self, _ctx: &ExpressionStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_fixed_statement(&mut self, _ctx: &FixedStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_fixed_statement(&mut self, _ctx: &FixedStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_for_statement(&mut self, _ctx: &ForStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_for_statement(&mut self, _ctx: &ForStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_goto_statement(&mut self, _ctx: &GotoStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_goto_statement(&mut self, _ctx: &GotoStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_if_statement(&mut self, _ctx: &IfStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_if_statement(&mut self, _ctx: &IfStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_else_clause(&mut self, _ctx: &ElseClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_else_clause(&mut self, _ctx: &ElseClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_labeled_statement(&mut self, _ctx: &LabeledStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_labeled_statement(&mut self, _ctx: &LabeledStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_local_declaration_statement(&mut self, _ctx: &LocalDeclarationStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_local_declaration_statement(&mut self, _ctx: &LocalDeclarationStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_local_function_statement(&mut self, _ctx: &LocalFunctionStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_local_function_statement(&mut self, _ctx: &LocalFunctionStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lock_statement(&mut self, _ctx: &LockStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lock_statement(&mut self, _ctx: &LockStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_return_statement(&mut self, _ctx: &ReturnStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_return_statement(&mut self, _ctx: &ReturnStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_statement(&mut self, _ctx: &SwitchStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_statement(&mut self, _ctx: &SwitchStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_section(&mut self, _ctx: &SwitchSectionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_section(&mut self, _ctx: &SwitchSectionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_label(&mut self, _ctx: &SwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_label(&mut self, _ctx: &SwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_case_pattern_switch_label(&mut self, _ctx: &CasePatternSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_case_pattern_switch_label(&mut self, _ctx: &CasePatternSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_pattern(&mut self, _ctx: &PatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_pattern(&mut self, _ctx: &PatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_constant_pattern(&mut self, _ctx: &ConstantPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_constant_pattern(&mut self, _ctx: &ConstantPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_declaration_pattern(&mut self, _ctx: &DeclarationPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_declaration_pattern(&mut self, _ctx: &DeclarationPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_designation(&mut self, _ctx: &VariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_designation(&mut self, _ctx: &VariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_discard_designation(&mut self, _ctx: &DiscardDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_discard_designation(&mut self, _ctx: &DiscardDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_variable_designation(&mut self, _ctx: &ParenthesizedVariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_variable_designation(&mut self, _ctx: &ParenthesizedVariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_single_variable_designation(&mut self, _ctx: &SingleVariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_single_variable_designation(&mut self, _ctx: &SingleVariableDesignationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_discard_pattern(&mut self, _ctx: &DiscardPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_discard_pattern(&mut self, _ctx: &DiscardPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_list_pattern(&mut self, _ctx: &ListPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_list_pattern(&mut self, _ctx: &ListPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_pattern(&mut self, _ctx: &ParenthesizedPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_pattern(&mut self, _ctx: &ParenthesizedPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_recursive_pattern(&mut self, _ctx: &RecursivePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_recursive_pattern(&mut self, _ctx: &RecursivePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_positional_pattern_clause(&mut self, _ctx: &PositionalPatternClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_positional_pattern_clause(&mut self, _ctx: &PositionalPatternClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_subpattern(&mut self, _ctx: &SubpatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_subpattern(&mut self, _ctx: &SubpatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_expression_colon(&mut self, _ctx: &BaseExpressionColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_expression_colon(&mut self, _ctx: &BaseExpressionColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_colon(&mut self, _ctx: &ExpressionColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_colon(&mut self, _ctx: &ExpressionColonContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_property_pattern_clause(&mut self, _ctx: &PropertyPatternClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_property_pattern_clause(&mut self, _ctx: &PropertyPatternClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_relational_pattern(&mut self, _ctx: &RelationalPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_relational_pattern(&mut self, _ctx: &RelationalPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_slice_pattern(&mut self, _ctx: &SlicePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_slice_pattern(&mut self, _ctx: &SlicePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_pattern(&mut self, _ctx: &TypePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_pattern(&mut self, _ctx: &TypePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unary_pattern(&mut self, _ctx: &UnaryPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unary_pattern(&mut self, _ctx: &UnaryPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_var_pattern(&mut self, _ctx: &VarPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_var_pattern(&mut self, _ctx: &VarPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_when_clause(&mut self, _ctx: &WhenClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_when_clause(&mut self, _ctx: &WhenClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_case_switch_label(&mut self, _ctx: &CaseSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_case_switch_label(&mut self, _ctx: &CaseSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_default_switch_label(&mut self, _ctx: &DefaultSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_default_switch_label(&mut self, _ctx: &DefaultSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_throw_statement(&mut self, _ctx: &ThrowStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_throw_statement(&mut self, _ctx: &ThrowStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_try_statement(&mut self, _ctx: &TryStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_try_statement(&mut self, _ctx: &TryStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_catch_clause(&mut self, _ctx: &CatchClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_catch_clause(&mut self, _ctx: &CatchClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_catch_declaration(&mut self, _ctx: &CatchDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_catch_declaration(&mut self, _ctx: &CatchDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_catch_filter_clause(&mut self, _ctx: &CatchFilterClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_catch_filter_clause(&mut self, _ctx: &CatchFilterClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_finally_clause(&mut self, _ctx: &FinallyClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_finally_clause(&mut self, _ctx: &FinallyClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unsafe_statement(&mut self, _ctx: &UnsafeStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unsafe_statement(&mut self, _ctx: &UnsafeStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_using_statement(&mut self, _ctx: &UsingStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_using_statement(&mut self, _ctx: &UsingStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_while_statement(&mut self, _ctx: &WhileStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_while_statement(&mut self, _ctx: &WhileStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_yield_statement(&mut self, _ctx: &YieldStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_yield_statement(&mut self, _ctx: &YieldStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression(&mut self, _ctx: &ExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression(&mut self, _ctx: &ExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_function_expression(&mut self, _ctx: &AnonymousFunctionExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_function_expression(&mut self, _ctx: &AnonymousFunctionExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_method_expression(&mut self, _ctx: &AnonymousMethodExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_method_expression(&mut self, _ctx: &AnonymousMethodExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lambda_expression(&mut self, _ctx: &LambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lambda_expression(&mut self, _ctx: &LambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_lambda_expression(&mut self, _ctx: &ParenthesizedLambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_lambda_expression(&mut self, _ctx: &ParenthesizedLambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_simple_lambda_expression(&mut self, _ctx: &SimpleLambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_simple_lambda_expression(&mut self, _ctx: &SimpleLambdaExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_object_creation_expression(&mut self, _ctx: &AnonymousObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_object_creation_expression(&mut self, _ctx: &AnonymousObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_anonymous_object_member_declarator(&mut self, _ctx: &AnonymousObjectMemberDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_anonymous_object_member_declarator(&mut self, _ctx: &AnonymousObjectMemberDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_array_creation_expression(&mut self, _ctx: &ArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_array_creation_expression(&mut self, _ctx: &ArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_initializer_expression(&mut self, _ctx: &InitializerExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_initializer_expression(&mut self, _ctx: &InitializerExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_await_expression(&mut self, _ctx: &AwaitExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_await_expression(&mut self, _ctx: &AwaitExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_object_creation_expression(&mut self, _ctx: &BaseObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_object_creation_expression(&mut self, _ctx: &BaseObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_implicit_object_creation_expression(&mut self, _ctx: &ImplicitObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_implicit_object_creation_expression(&mut self, _ctx: &ImplicitObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_object_creation_expression(&mut self, _ctx: &ObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_object_creation_expression(&mut self, _ctx: &ObjectCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_cast_expression(&mut self, _ctx: &CastExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_cast_expression(&mut self, _ctx: &CastExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_checked_expression(&mut self, _ctx: &CheckedExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_checked_expression(&mut self, _ctx: &CheckedExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_collection_expression(&mut self, _ctx: &CollectionExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_collection_expression(&mut self, _ctx: &CollectionExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_collection_element(&mut self, _ctx: &CollectionElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_collection_element(&mut self, _ctx: &CollectionElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_element(&mut self, _ctx: &ExpressionElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_element(&mut self, _ctx: &ExpressionElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_spread_element(&mut self, _ctx: &SpreadElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_spread_element(&mut self, _ctx: &SpreadElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_with_element(&mut self, _ctx: &WithElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_with_element(&mut self, _ctx: &WithElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_declaration_expression(&mut self, _ctx: &DeclarationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_declaration_expression(&mut self, _ctx: &DeclarationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_default_expression(&mut self, _ctx: &DefaultExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_default_expression(&mut self, _ctx: &DefaultExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element_binding_expression(&mut self, _ctx: &ElementBindingExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element_binding_expression(&mut self, _ctx: &ElementBindingExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_field_expression(&mut self, _ctx: &FieldExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_field_expression(&mut self, _ctx: &FieldExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_implicit_array_creation_expression(&mut self, _ctx: &ImplicitArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_implicit_array_creation_expression(&mut self, _ctx: &ImplicitArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_implicit_element_access(&mut self, _ctx: &ImplicitElementAccessContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_implicit_element_access(&mut self, _ctx: &ImplicitElementAccessContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_implicit_stack_alloc_array_creation_expression(&mut self, _ctx: &ImplicitStackAllocArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_implicit_stack_alloc_array_creation_expression(&mut self, _ctx: &ImplicitStackAllocArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_instance_expression(&mut self, _ctx: &InstanceExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_instance_expression(&mut self, _ctx: &InstanceExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_base_expression(&mut self, _ctx: &BaseExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_base_expression(&mut self, _ctx: &BaseExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_this_expression(&mut self, _ctx: &ThisExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_this_expression(&mut self, _ctx: &ThisExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_expression(&mut self, _ctx: &InterpolatedStringExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_expression(&mut self, _ctx: &InterpolatedStringExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_content(&mut self, _ctx: &InterpolatedStringContentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_content(&mut self, _ctx: &InterpolatedStringContentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_text(&mut self, _ctx: &InterpolatedStringTextContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_text(&mut self, _ctx: &InterpolatedStringTextContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolation(&mut self, _ctx: &InterpolationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolation(&mut self, _ctx: &InterpolationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolation_alignment_clause(&mut self, _ctx: &InterpolationAlignmentClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolation_alignment_clause(&mut self, _ctx: &InterpolationAlignmentClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolation_format_clause(&mut self, _ctx: &InterpolationFormatClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolation_format_clause(&mut self, _ctx: &InterpolationFormatClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_multi_line_raw_string_start_token(&mut self, _ctx: &InterpolatedMultiLineRawStringStartTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_multi_line_raw_string_start_token(&mut self, _ctx: &InterpolatedMultiLineRawStringStartTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_raw_string_end_token(&mut self, _ctx: &InterpolatedRawStringEndTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_raw_string_end_token(&mut self, _ctx: &InterpolatedRawStringEndTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_single_line_raw_string_start_token(&mut self, _ctx: &InterpolatedSingleLineRawStringStartTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_single_line_raw_string_start_token(&mut self, _ctx: &InterpolatedSingleLineRawStringStartTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_literal_expression(&mut self, _ctx: &LiteralExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_literal_expression(&mut self, _ctx: &LiteralExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_utf8_multi_line_raw_string_literal_token(&mut self, _ctx: &Utf8MultiLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_utf8_multi_line_raw_string_literal_token(&mut self, _ctx: &Utf8MultiLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_utf8_single_line_raw_string_literal_token(&mut self, _ctx: &Utf8SingleLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_utf8_single_line_raw_string_literal_token(&mut self, _ctx: &Utf8SingleLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_utf8_string_literal_token(&mut self, _ctx: &Utf8StringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_utf8_string_literal_token(&mut self, _ctx: &Utf8StringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_make_ref_expression(&mut self, _ctx: &MakeRefExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_make_ref_expression(&mut self, _ctx: &MakeRefExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_member_binding_expression(&mut self, _ctx: &MemberBindingExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_member_binding_expression(&mut self, _ctx: &MemberBindingExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parenthesized_expression(&mut self, _ctx: &ParenthesizedExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parenthesized_expression(&mut self, _ctx: &ParenthesizedExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_prefix_unary_expression(&mut self, _ctx: &PrefixUnaryExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_prefix_unary_expression(&mut self, _ctx: &PrefixUnaryExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_query_expression(&mut self, _ctx: &QueryExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_query_expression(&mut self, _ctx: &QueryExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_from_clause(&mut self, _ctx: &FromClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_from_clause(&mut self, _ctx: &FromClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_query_body(&mut self, _ctx: &QueryBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_query_body(&mut self, _ctx: &QueryBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_query_clause(&mut self, _ctx: &QueryClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_query_clause(&mut self, _ctx: &QueryClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_join_clause(&mut self, _ctx: &JoinClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_join_clause(&mut self, _ctx: &JoinClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_join_into_clause(&mut self, _ctx: &JoinIntoClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_join_into_clause(&mut self, _ctx: &JoinIntoClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_let_clause(&mut self, _ctx: &LetClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_let_clause(&mut self, _ctx: &LetClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_order_by_clause(&mut self, _ctx: &OrderByClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_order_by_clause(&mut self, _ctx: &OrderByClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ordering(&mut self, _ctx: &OrderingContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ordering(&mut self, _ctx: &OrderingContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_where_clause(&mut self, _ctx: &WhereClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_where_clause(&mut self, _ctx: &WhereClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_select_or_group_clause(&mut self, _ctx: &SelectOrGroupClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_select_or_group_clause(&mut self, _ctx: &SelectOrGroupClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_group_clause(&mut self, _ctx: &GroupClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_group_clause(&mut self, _ctx: &GroupClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_select_clause(&mut self, _ctx: &SelectClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_select_clause(&mut self, _ctx: &SelectClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_query_continuation(&mut self, _ctx: &QueryContinuationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_query_continuation(&mut self, _ctx: &QueryContinuationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ref_expression(&mut self, _ctx: &RefExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ref_expression(&mut self, _ctx: &RefExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ref_type_expression(&mut self, _ctx: &RefTypeExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ref_type_expression(&mut self, _ctx: &RefTypeExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ref_value_expression(&mut self, _ctx: &RefValueExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ref_value_expression(&mut self, _ctx: &RefValueExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_size_of_expression(&mut self, _ctx: &SizeOfExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_size_of_expression(&mut self, _ctx: &SizeOfExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_stack_alloc_array_creation_expression(&mut self, _ctx: &StackAllocArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_stack_alloc_array_creation_expression(&mut self, _ctx: &StackAllocArrayCreationExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_expression_arm(&mut self, _ctx: &SwitchExpressionArmContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_expression_arm(&mut self, _ctx: &SwitchExpressionArmContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_throw_expression(&mut self, _ctx: &ThrowExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_throw_expression(&mut self, _ctx: &ThrowExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_tuple_expression(&mut self, _ctx: &TupleExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_tuple_expression(&mut self, _ctx: &TupleExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_of_expression(&mut self, _ctx: &TypeOfExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_of_expression(&mut self, _ctx: &TypeOfExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unsafe_expression(&mut self, _ctx: &UnsafeExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unsafe_expression(&mut self, _ctx: &UnsafeExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_syntax_token(&mut self, _ctx: &SyntaxTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_syntax_token(&mut self, _ctx: &SyntaxTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_identifier_token(&mut self, _ctx: &IdentifierTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_identifier_token(&mut self, _ctx: &IdentifierTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_keyword(&mut self, _ctx: &KeywordContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_keyword(&mut self, _ctx: &KeywordContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_numeric_literal_token(&mut self, _ctx: &NumericLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_numeric_literal_token(&mut self, _ctx: &NumericLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_integer_literal_token(&mut self, _ctx: &IntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_integer_literal_token(&mut self, _ctx: &IntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_decimal_integer_literal_token(&mut self, _ctx: &DecimalIntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_decimal_integer_literal_token(&mut self, _ctx: &DecimalIntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_hexadecimal_integer_literal_token(&mut self, _ctx: &HexadecimalIntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_hexadecimal_integer_literal_token(&mut self, _ctx: &HexadecimalIntegerLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_real_literal_token(&mut self, _ctx: &RealLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_real_literal_token(&mut self, _ctx: &RealLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_character_literal_token(&mut self, _ctx: &CharacterLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_character_literal_token(&mut self, _ctx: &CharacterLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_string_literal_token(&mut self, _ctx: &StringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_string_literal_token(&mut self, _ctx: &StringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_regular_string_literal_token(&mut self, _ctx: &RegularStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_regular_string_literal_token(&mut self, _ctx: &RegularStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_verbatim_string_literal_token(&mut self, _ctx: &VerbatimStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_verbatim_string_literal_token(&mut self, _ctx: &VerbatimStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_operator_token(&mut self, _ctx: &OperatorTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_operator_token(&mut self, _ctx: &OperatorTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_punctuation_token(&mut self, _ctx: &PunctuationTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_punctuation_token(&mut self, _ctx: &PunctuationTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interpolated_string_text_token(&mut self, _ctx: &InterpolatedStringTextTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interpolated_string_text_token(&mut self, _ctx: &InterpolatedStringTextTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_multi_line_raw_string_literal_token(&mut self, _ctx: &MultiLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_multi_line_raw_string_literal_token(&mut self, _ctx: &MultiLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_single_line_raw_string_literal_token(&mut self, _ctx: &SingleLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_single_line_raw_string_literal_token(&mut self, _ctx: &SingleLineRawStringLiteralTokenContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_record_keyword(&mut self, _ctx: &RecordKeywordContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_keyword(&mut self, _ctx: &RecordKeywordContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_right_shift(&mut self, _ctx: &RightShiftContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_right_shift(&mut self, _ctx: &RightShiftContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unsigned_right_shift(&mut self, _ctx: &UnsignedRightShiftContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unsigned_right_shift(&mut self, _ctx: &UnsignedRightShiftContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_right_shift_assignment(&mut self, _ctx: &RightShiftAssignmentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_right_shift_assignment(&mut self, _ctx: &RightShiftAssignmentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unsigned_right_shift_assignment(&mut self, _ctx: &UnsignedRightShiftAssignmentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unsigned_right_shift_assignment(&mut self, _ctx: &UnsignedRightShiftAssignmentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_local_variable_declaration(&mut self, _ctx: &LocalVariableDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_local_variable_declaration(&mut self, _ctx: &LocalVariableDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_local_variable_declarator(&mut self, _ctx: &LocalVariableDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_local_variable_declarator(&mut self, _ctx: &LocalVariableDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn visit_terminal(&mut self, _node: &TerminalNode) -> Result<(), E> { Ok(()) }
    fn output(&mut self) -> std::io::Stdout { std::io::stdout() }
}

#[allow(dead_code)]
pub struct CSharpValidatedTreeWalker;

#[allow(dead_code)]
impl CSharpValidatedTreeWalker {
    pub fn walk<E, T: CSharpValidatedListener<E>>(
        listener: &mut T,
        tree: ValidatedRuleNode<'_>,
    ) -> Result<(), E> {
        Self::__walk(listener, tree.node(), None)
    }

    pub fn walk_with_invocation_states<E, T: CSharpValidatedListener<E>>(
        listener: &mut T,
        tree: ValidatedRuleNode<'_>,
        parent_invocation_states: Vec<isize>,
    ) -> Result<(), E> {
        Self::__walk(listener, tree.node(), Some(parent_invocation_states))
    }

    fn __walk<E, T: CSharpValidatedListener<E>>(
        listener: &mut T,
        tree: antlr4_runtime::Node<'_>,
        mut invocation_states: Option<Vec<isize>>,
    ) -> Result<(), E> {
        enum Event<'tree> {
            Enter(antlr4_runtime::Node<'tree>),
            Exit(RuleNodeView<'tree>),
        }

        let mut stack = vec![Event::Enter(tree)];
        while let Some(event) = stack.pop() {
            match event {
                Event::Enter(node) => match node.kind() {
                    antlr4_runtime::NodeKind::Rule => {
                        let context = node.as_rule().expect("rule node kind checked");
                        if let Some(states) = &mut invocation_states {
                            states.insert(0, context.invoking_state());
                        }
                        listener.enter_every_rule(ValidatedRuleNode { __node: context })?;
                        match __context_kind(context) {
                        0 => listener.enter_compilation_unit(&CompilationUnitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        1 => listener.enter_extern_alias_directive(&ExternAliasDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_using_directive(&UsingDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_name_equals(&NameEqualsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_identifier_name(&IdentifierNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_attribute_list(&AttributeListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_attribute_target_specifier(&AttributeTargetSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_attribute(&AttributeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_name(&NameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_alias_qualified_name(&AliasQualifiedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_simple_name(&SimpleNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_generic_name(&GenericNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_type_argument_list(&TypeArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_attribute_argument_list(&AttributeArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_attribute_argument(&AttributeArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_name_colon(&NameColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_member_declaration(&MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_base_field_declaration(&BaseFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_event_field_declaration(&EventFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_modifier(&ModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_variable_declaration(&VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_variable_declarator(&VariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_bracketed_argument_list(&BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_argument(&ArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_equals_value_clause(&EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_field_declaration(&FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_base_method_declaration(&BaseMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_constructor_declaration(&ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_parameter_list(&ParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_parameter(&ParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_constructor_initializer(&ConstructorInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_argument_list(&ArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_arrow_expression_clause(&ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_conversion_operator_declaration(&ConversionOperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_explicit_interface_specifier(&ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_destructor_declaration(&DestructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_method_declaration(&MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_type_parameter_list(&TypeParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_type_parameter(&TypeParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_type_parameter_constraint_clause(&TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_type_parameter_constraint(&TypeParameterConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_allows_constraint_clause(&AllowsConstraintClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_allows_constraint(&AllowsConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_ref_struct_constraint(&RefStructConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_class_or_struct_constraint(&ClassOrStructConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_constructor_constraint(&ConstructorConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_default_constraint(&DefaultConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_type_constraint(&TypeConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_operator_declaration(&OperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_base_namespace_declaration(&BaseNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_file_scoped_namespace_declaration(&FileScopedNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_namespace_declaration(&NamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_base_property_declaration(&BasePropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_event_declaration(&EventDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_accessor_list(&AccessorListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_accessor_declaration(&AccessorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_indexer_declaration(&IndexerDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_bracketed_parameter_list(&BracketedParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_property_declaration(&PropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_base_type_declaration(&BaseTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_enum_declaration(&EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_base_list(&BaseListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_base_type(&BaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_primary_constructor_base_type(&PrimaryConstructorBaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_simple_base_type(&SimpleBaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_enum_member_declaration(&EnumMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        67 => listener.enter_type_declaration(&TypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        68 => listener.enter_class_declaration(&ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        69 => listener.enter_extension_block_declaration(&ExtensionBlockDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        70 => listener.enter_interface_declaration(&InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        71 => listener.enter_record_declaration(&RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        72 => listener.enter_struct_declaration(&StructDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        73 => listener.enter_union_declaration(&UnionDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        74 => listener.enter_delegate_declaration(&DelegateDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        75 => listener.enter_global_statement(&GlobalStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        76 => listener.enter_type(&TypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        77 => listener.enter_array_type(&ArrayTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        78 => listener.enter_array_rank_specifier(&ArrayRankSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        79 => listener.enter_function_pointer_type(&FunctionPointerTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        80 => listener.enter_function_pointer_calling_convention(&FunctionPointerCallingConventionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        81 => listener.enter_function_pointer_unmanaged_calling_convention_list(&FunctionPointerUnmanagedCallingConventionListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        82 => listener.enter_function_pointer_unmanaged_calling_convention(&FunctionPointerUnmanagedCallingConventionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        83 => listener.enter_function_pointer_parameter_list(&FunctionPointerParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        84 => listener.enter_function_pointer_parameter(&FunctionPointerParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        85 => listener.enter_predefined_type(&PredefinedTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        86 => listener.enter_ref_type(&RefTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        87 => listener.enter_scoped_type(&ScopedTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        88 => listener.enter_tuple_type(&TupleTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        89 => listener.enter_tuple_element(&TupleElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        90 => listener.enter_statement(&StatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        91 => listener.enter_break_statement(&BreakStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        92 => listener.enter_checked_statement(&CheckedStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        93 => listener.enter_common_for_each_statement(&CommonForEachStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        94 => listener.enter_for_each_statement(&ForEachStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        95 => listener.enter_for_each_variable_statement(&ForEachVariableStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        96 => listener.enter_continue_statement(&ContinueStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        97 => listener.enter_do_statement(&DoStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        98 => listener.enter_empty_statement(&EmptyStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        99 => listener.enter_expression_statement(&ExpressionStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        100 => listener.enter_fixed_statement(&FixedStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        101 => listener.enter_for_statement(&ForStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        102 => listener.enter_goto_statement(&GotoStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        103 => listener.enter_if_statement(&IfStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        104 => listener.enter_else_clause(&ElseClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        105 => listener.enter_labeled_statement(&LabeledStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        106 => listener.enter_local_declaration_statement(&LocalDeclarationStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        107 => listener.enter_local_function_statement(&LocalFunctionStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        108 => listener.enter_lock_statement(&LockStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        109 => listener.enter_return_statement(&ReturnStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        110 => listener.enter_switch_statement(&SwitchStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        111 => listener.enter_switch_section(&SwitchSectionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        112 => listener.enter_switch_label(&SwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        113 => listener.enter_case_pattern_switch_label(&CasePatternSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        114 => listener.enter_pattern(&PatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        115 => listener.enter_constant_pattern(&ConstantPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        116 => listener.enter_declaration_pattern(&DeclarationPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        117 => listener.enter_variable_designation(&VariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        118 => listener.enter_discard_designation(&DiscardDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        119 => listener.enter_parenthesized_variable_designation(&ParenthesizedVariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        120 => listener.enter_single_variable_designation(&SingleVariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        121 => listener.enter_discard_pattern(&DiscardPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        122 => listener.enter_list_pattern(&ListPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        123 => listener.enter_parenthesized_pattern(&ParenthesizedPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        124 => listener.enter_recursive_pattern(&RecursivePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        125 => listener.enter_positional_pattern_clause(&PositionalPatternClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        126 => listener.enter_subpattern(&SubpatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        127 => listener.enter_base_expression_colon(&BaseExpressionColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        128 => listener.enter_expression_colon(&ExpressionColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        129 => listener.enter_property_pattern_clause(&PropertyPatternClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        130 => listener.enter_relational_pattern(&RelationalPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        131 => listener.enter_slice_pattern(&SlicePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        132 => listener.enter_type_pattern(&TypePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        133 => listener.enter_unary_pattern(&UnaryPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        134 => listener.enter_var_pattern(&VarPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        135 => listener.enter_when_clause(&WhenClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        136 => listener.enter_case_switch_label(&CaseSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        137 => listener.enter_default_switch_label(&DefaultSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        138 => listener.enter_throw_statement(&ThrowStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        139 => listener.enter_try_statement(&TryStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        140 => listener.enter_catch_clause(&CatchClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        141 => listener.enter_catch_declaration(&CatchDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        142 => listener.enter_catch_filter_clause(&CatchFilterClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        143 => listener.enter_finally_clause(&FinallyClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        144 => listener.enter_unsafe_statement(&UnsafeStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        145 => listener.enter_using_statement(&UsingStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        146 => listener.enter_while_statement(&WhileStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        147 => listener.enter_yield_statement(&YieldStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        148 => listener.enter_expression(&ExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        149 => listener.enter_anonymous_function_expression(&AnonymousFunctionExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        150 => listener.enter_anonymous_method_expression(&AnonymousMethodExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        151 => listener.enter_lambda_expression(&LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        152 => listener.enter_parenthesized_lambda_expression(&ParenthesizedLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        153 => listener.enter_simple_lambda_expression(&SimpleLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        154 => listener.enter_anonymous_object_creation_expression(&AnonymousObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        155 => listener.enter_anonymous_object_member_declarator(&AnonymousObjectMemberDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        156 => listener.enter_array_creation_expression(&ArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        157 => listener.enter_initializer_expression(&InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        158 => listener.enter_await_expression(&AwaitExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        159 => listener.enter_base_object_creation_expression(&BaseObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        160 => listener.enter_implicit_object_creation_expression(&ImplicitObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        161 => listener.enter_object_creation_expression(&ObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        162 => listener.enter_cast_expression(&CastExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        163 => listener.enter_checked_expression(&CheckedExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        164 => listener.enter_collection_expression(&CollectionExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        165 => listener.enter_collection_element(&CollectionElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        166 => listener.enter_expression_element(&ExpressionElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        167 => listener.enter_spread_element(&SpreadElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        168 => listener.enter_with_element(&WithElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        169 => listener.enter_declaration_expression(&DeclarationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        170 => listener.enter_default_expression(&DefaultExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        171 => listener.enter_element_binding_expression(&ElementBindingExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        172 => listener.enter_field_expression(&FieldExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        173 => listener.enter_implicit_array_creation_expression(&ImplicitArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        174 => listener.enter_implicit_element_access(&ImplicitElementAccessContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        175 => listener.enter_implicit_stack_alloc_array_creation_expression(&ImplicitStackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        176 => listener.enter_instance_expression(&InstanceExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        177 => listener.enter_base_expression(&BaseExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        178 => listener.enter_this_expression(&ThisExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        179 => listener.enter_interpolated_string_expression(&InterpolatedStringExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        180 => listener.enter_interpolated_string_content(&InterpolatedStringContentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        181 => listener.enter_interpolated_string_text(&InterpolatedStringTextContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        182 => listener.enter_interpolation(&InterpolationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        183 => listener.enter_interpolation_alignment_clause(&InterpolationAlignmentClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        184 => listener.enter_interpolation_format_clause(&InterpolationFormatClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        185 => listener.enter_interpolated_multi_line_raw_string_start_token(&InterpolatedMultiLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        186 => listener.enter_interpolated_raw_string_end_token(&InterpolatedRawStringEndTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        187 => listener.enter_interpolated_single_line_raw_string_start_token(&InterpolatedSingleLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        188 => listener.enter_literal_expression(&LiteralExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        189 => listener.enter_utf8_multi_line_raw_string_literal_token(&Utf8MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        190 => listener.enter_utf8_single_line_raw_string_literal_token(&Utf8SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        191 => listener.enter_utf8_string_literal_token(&Utf8StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        192 => listener.enter_make_ref_expression(&MakeRefExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        193 => listener.enter_member_binding_expression(&MemberBindingExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        194 => listener.enter_parenthesized_expression(&ParenthesizedExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        195 => listener.enter_prefix_unary_expression(&PrefixUnaryExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        196 => listener.enter_query_expression(&QueryExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        197 => listener.enter_from_clause(&FromClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        198 => listener.enter_query_body(&QueryBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        199 => listener.enter_query_clause(&QueryClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        200 => listener.enter_join_clause(&JoinClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        201 => listener.enter_join_into_clause(&JoinIntoClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        202 => listener.enter_let_clause(&LetClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        203 => listener.enter_order_by_clause(&OrderByClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        204 => listener.enter_ordering(&OrderingContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        205 => listener.enter_where_clause(&WhereClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        206 => listener.enter_select_or_group_clause(&SelectOrGroupClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        207 => listener.enter_group_clause(&GroupClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        208 => listener.enter_select_clause(&SelectClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        209 => listener.enter_query_continuation(&QueryContinuationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        210 => listener.enter_ref_expression(&RefExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        211 => listener.enter_ref_type_expression(&RefTypeExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        212 => listener.enter_ref_value_expression(&RefValueExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        213 => listener.enter_size_of_expression(&SizeOfExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        214 => listener.enter_stack_alloc_array_creation_expression(&StackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        215 => listener.enter_switch_expression_arm(&SwitchExpressionArmContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        216 => listener.enter_throw_expression(&ThrowExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        217 => listener.enter_tuple_expression(&TupleExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        218 => listener.enter_type_of_expression(&TypeOfExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        219 => listener.enter_unsafe_expression(&UnsafeExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        220 => listener.enter_syntax_token(&SyntaxTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        221 => listener.enter_identifier_token(&IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        222 => listener.enter_keyword(&KeywordContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        223 => listener.enter_numeric_literal_token(&NumericLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        224 => listener.enter_integer_literal_token(&IntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        225 => listener.enter_decimal_integer_literal_token(&DecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        226 => listener.enter_hexadecimal_integer_literal_token(&HexadecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        227 => listener.enter_real_literal_token(&RealLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        228 => listener.enter_character_literal_token(&CharacterLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        229 => listener.enter_string_literal_token(&StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        230 => listener.enter_regular_string_literal_token(&RegularStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        231 => listener.enter_verbatim_string_literal_token(&VerbatimStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        232 => listener.enter_operator_token(&OperatorTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        233 => listener.enter_punctuation_token(&PunctuationTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        234 => listener.enter_interpolated_string_text_token(&InterpolatedStringTextTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        235 => listener.enter_multi_line_raw_string_literal_token(&MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        236 => listener.enter_single_line_raw_string_literal_token(&SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        237 => listener.enter_record_keyword(&RecordKeywordContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        238 => listener.enter_right_shift(&RightShiftContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        239 => listener.enter_unsigned_right_shift(&UnsignedRightShiftContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        240 => listener.enter_right_shift_assignment(&RightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        241 => listener.enter_unsigned_right_shift_assignment(&UnsignedRightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        242 => listener.enter_local_variable_declaration(&LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        243 => listener.enter_local_variable_declarator(&LocalVariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                            _ => {}
                        }
                        stack.push(Event::Exit(context));
                        stack.extend(context.children().rev().map(Event::Enter));
                    }
                    antlr4_runtime::NodeKind::Terminal => {
                        listener.visit_terminal(&TerminalNode::new(
                            node.as_terminal().expect("terminal node kind checked"),
                        ))?;
                    }
                    antlr4_runtime::NodeKind::Error => {
                        unreachable!("validated parse tree contains an error node")
                    }
                },
                Event::Exit(context) => {
                    match __context_kind(context) {
                    0 => listener.exit_compilation_unit(&CompilationUnitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    1 => listener.exit_extern_alias_directive(&ExternAliasDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_using_directive(&UsingDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_name_equals(&NameEqualsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_identifier_name(&IdentifierNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_attribute_list(&AttributeListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_attribute_target_specifier(&AttributeTargetSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_attribute(&AttributeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_name(&NameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_alias_qualified_name(&AliasQualifiedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_simple_name(&SimpleNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_generic_name(&GenericNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_type_argument_list(&TypeArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_attribute_argument_list(&AttributeArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_attribute_argument(&AttributeArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_name_colon(&NameColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_member_declaration(&MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_base_field_declaration(&BaseFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_event_field_declaration(&EventFieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_modifier(&ModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_variable_declaration(&VariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_variable_declarator(&VariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_bracketed_argument_list(&BracketedArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_argument(&ArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_equals_value_clause(&EqualsValueClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_field_declaration(&FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_base_method_declaration(&BaseMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_constructor_declaration(&ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_parameter_list(&ParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_parameter(&ParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_constructor_initializer(&ConstructorInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_argument_list(&ArgumentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_arrow_expression_clause(&ArrowExpressionClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_conversion_operator_declaration(&ConversionOperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_explicit_interface_specifier(&ExplicitInterfaceSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_destructor_declaration(&DestructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_method_declaration(&MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_type_parameter_list(&TypeParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_type_parameter(&TypeParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_type_parameter_constraint_clause(&TypeParameterConstraintClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_type_parameter_constraint(&TypeParameterConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_allows_constraint_clause(&AllowsConstraintClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_allows_constraint(&AllowsConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_ref_struct_constraint(&RefStructConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_class_or_struct_constraint(&ClassOrStructConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_constructor_constraint(&ConstructorConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_default_constraint(&DefaultConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_type_constraint(&TypeConstraintContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_operator_declaration(&OperatorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_base_namespace_declaration(&BaseNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_file_scoped_namespace_declaration(&FileScopedNamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_namespace_declaration(&NamespaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_base_property_declaration(&BasePropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_event_declaration(&EventDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_accessor_list(&AccessorListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_accessor_declaration(&AccessorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_indexer_declaration(&IndexerDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_bracketed_parameter_list(&BracketedParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_property_declaration(&PropertyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_base_type_declaration(&BaseTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_enum_declaration(&EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_base_list(&BaseListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_base_type(&BaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_primary_constructor_base_type(&PrimaryConstructorBaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_simple_base_type(&SimpleBaseTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_enum_member_declaration(&EnumMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    67 => listener.exit_type_declaration(&TypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    68 => listener.exit_class_declaration(&ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    69 => listener.exit_extension_block_declaration(&ExtensionBlockDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    70 => listener.exit_interface_declaration(&InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    71 => listener.exit_record_declaration(&RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    72 => listener.exit_struct_declaration(&StructDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    73 => listener.exit_union_declaration(&UnionDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    74 => listener.exit_delegate_declaration(&DelegateDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    75 => listener.exit_global_statement(&GlobalStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    76 => listener.exit_type(&TypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    77 => listener.exit_array_type(&ArrayTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    78 => listener.exit_array_rank_specifier(&ArrayRankSpecifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    79 => listener.exit_function_pointer_type(&FunctionPointerTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    80 => listener.exit_function_pointer_calling_convention(&FunctionPointerCallingConventionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    81 => listener.exit_function_pointer_unmanaged_calling_convention_list(&FunctionPointerUnmanagedCallingConventionListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    82 => listener.exit_function_pointer_unmanaged_calling_convention(&FunctionPointerUnmanagedCallingConventionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    83 => listener.exit_function_pointer_parameter_list(&FunctionPointerParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    84 => listener.exit_function_pointer_parameter(&FunctionPointerParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    85 => listener.exit_predefined_type(&PredefinedTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    86 => listener.exit_ref_type(&RefTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    87 => listener.exit_scoped_type(&ScopedTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    88 => listener.exit_tuple_type(&TupleTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    89 => listener.exit_tuple_element(&TupleElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    90 => listener.exit_statement(&StatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    91 => listener.exit_break_statement(&BreakStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    92 => listener.exit_checked_statement(&CheckedStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    93 => listener.exit_common_for_each_statement(&CommonForEachStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    94 => listener.exit_for_each_statement(&ForEachStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    95 => listener.exit_for_each_variable_statement(&ForEachVariableStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    96 => listener.exit_continue_statement(&ContinueStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    97 => listener.exit_do_statement(&DoStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    98 => listener.exit_empty_statement(&EmptyStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    99 => listener.exit_expression_statement(&ExpressionStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    100 => listener.exit_fixed_statement(&FixedStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    101 => listener.exit_for_statement(&ForStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    102 => listener.exit_goto_statement(&GotoStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    103 => listener.exit_if_statement(&IfStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    104 => listener.exit_else_clause(&ElseClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    105 => listener.exit_labeled_statement(&LabeledStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    106 => listener.exit_local_declaration_statement(&LocalDeclarationStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    107 => listener.exit_local_function_statement(&LocalFunctionStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    108 => listener.exit_lock_statement(&LockStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    109 => listener.exit_return_statement(&ReturnStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    110 => listener.exit_switch_statement(&SwitchStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    111 => listener.exit_switch_section(&SwitchSectionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    112 => listener.exit_switch_label(&SwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    113 => listener.exit_case_pattern_switch_label(&CasePatternSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    114 => listener.exit_pattern(&PatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    115 => listener.exit_constant_pattern(&ConstantPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    116 => listener.exit_declaration_pattern(&DeclarationPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    117 => listener.exit_variable_designation(&VariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    118 => listener.exit_discard_designation(&DiscardDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    119 => listener.exit_parenthesized_variable_designation(&ParenthesizedVariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    120 => listener.exit_single_variable_designation(&SingleVariableDesignationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    121 => listener.exit_discard_pattern(&DiscardPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    122 => listener.exit_list_pattern(&ListPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    123 => listener.exit_parenthesized_pattern(&ParenthesizedPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    124 => listener.exit_recursive_pattern(&RecursivePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    125 => listener.exit_positional_pattern_clause(&PositionalPatternClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    126 => listener.exit_subpattern(&SubpatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    127 => listener.exit_base_expression_colon(&BaseExpressionColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    128 => listener.exit_expression_colon(&ExpressionColonContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    129 => listener.exit_property_pattern_clause(&PropertyPatternClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    130 => listener.exit_relational_pattern(&RelationalPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    131 => listener.exit_slice_pattern(&SlicePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    132 => listener.exit_type_pattern(&TypePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    133 => listener.exit_unary_pattern(&UnaryPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    134 => listener.exit_var_pattern(&VarPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    135 => listener.exit_when_clause(&WhenClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    136 => listener.exit_case_switch_label(&CaseSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    137 => listener.exit_default_switch_label(&DefaultSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    138 => listener.exit_throw_statement(&ThrowStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    139 => listener.exit_try_statement(&TryStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    140 => listener.exit_catch_clause(&CatchClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    141 => listener.exit_catch_declaration(&CatchDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    142 => listener.exit_catch_filter_clause(&CatchFilterClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    143 => listener.exit_finally_clause(&FinallyClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    144 => listener.exit_unsafe_statement(&UnsafeStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    145 => listener.exit_using_statement(&UsingStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    146 => listener.exit_while_statement(&WhileStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    147 => listener.exit_yield_statement(&YieldStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    148 => listener.exit_expression(&ExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    149 => listener.exit_anonymous_function_expression(&AnonymousFunctionExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    150 => listener.exit_anonymous_method_expression(&AnonymousMethodExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    151 => listener.exit_lambda_expression(&LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    152 => listener.exit_parenthesized_lambda_expression(&ParenthesizedLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    153 => listener.exit_simple_lambda_expression(&SimpleLambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    154 => listener.exit_anonymous_object_creation_expression(&AnonymousObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    155 => listener.exit_anonymous_object_member_declarator(&AnonymousObjectMemberDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    156 => listener.exit_array_creation_expression(&ArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    157 => listener.exit_initializer_expression(&InitializerExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    158 => listener.exit_await_expression(&AwaitExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    159 => listener.exit_base_object_creation_expression(&BaseObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    160 => listener.exit_implicit_object_creation_expression(&ImplicitObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    161 => listener.exit_object_creation_expression(&ObjectCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    162 => listener.exit_cast_expression(&CastExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    163 => listener.exit_checked_expression(&CheckedExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    164 => listener.exit_collection_expression(&CollectionExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    165 => listener.exit_collection_element(&CollectionElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    166 => listener.exit_expression_element(&ExpressionElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    167 => listener.exit_spread_element(&SpreadElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    168 => listener.exit_with_element(&WithElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    169 => listener.exit_declaration_expression(&DeclarationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    170 => listener.exit_default_expression(&DefaultExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    171 => listener.exit_element_binding_expression(&ElementBindingExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    172 => listener.exit_field_expression(&FieldExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    173 => listener.exit_implicit_array_creation_expression(&ImplicitArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    174 => listener.exit_implicit_element_access(&ImplicitElementAccessContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    175 => listener.exit_implicit_stack_alloc_array_creation_expression(&ImplicitStackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    176 => listener.exit_instance_expression(&InstanceExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    177 => listener.exit_base_expression(&BaseExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    178 => listener.exit_this_expression(&ThisExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    179 => listener.exit_interpolated_string_expression(&InterpolatedStringExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    180 => listener.exit_interpolated_string_content(&InterpolatedStringContentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    181 => listener.exit_interpolated_string_text(&InterpolatedStringTextContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    182 => listener.exit_interpolation(&InterpolationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    183 => listener.exit_interpolation_alignment_clause(&InterpolationAlignmentClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    184 => listener.exit_interpolation_format_clause(&InterpolationFormatClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    185 => listener.exit_interpolated_multi_line_raw_string_start_token(&InterpolatedMultiLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    186 => listener.exit_interpolated_raw_string_end_token(&InterpolatedRawStringEndTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    187 => listener.exit_interpolated_single_line_raw_string_start_token(&InterpolatedSingleLineRawStringStartTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    188 => listener.exit_literal_expression(&LiteralExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    189 => listener.exit_utf8_multi_line_raw_string_literal_token(&Utf8MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    190 => listener.exit_utf8_single_line_raw_string_literal_token(&Utf8SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    191 => listener.exit_utf8_string_literal_token(&Utf8StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    192 => listener.exit_make_ref_expression(&MakeRefExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    193 => listener.exit_member_binding_expression(&MemberBindingExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    194 => listener.exit_parenthesized_expression(&ParenthesizedExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    195 => listener.exit_prefix_unary_expression(&PrefixUnaryExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    196 => listener.exit_query_expression(&QueryExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    197 => listener.exit_from_clause(&FromClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    198 => listener.exit_query_body(&QueryBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    199 => listener.exit_query_clause(&QueryClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    200 => listener.exit_join_clause(&JoinClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    201 => listener.exit_join_into_clause(&JoinIntoClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    202 => listener.exit_let_clause(&LetClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    203 => listener.exit_order_by_clause(&OrderByClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    204 => listener.exit_ordering(&OrderingContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    205 => listener.exit_where_clause(&WhereClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    206 => listener.exit_select_or_group_clause(&SelectOrGroupClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    207 => listener.exit_group_clause(&GroupClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    208 => listener.exit_select_clause(&SelectClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    209 => listener.exit_query_continuation(&QueryContinuationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    210 => listener.exit_ref_expression(&RefExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    211 => listener.exit_ref_type_expression(&RefTypeExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    212 => listener.exit_ref_value_expression(&RefValueExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    213 => listener.exit_size_of_expression(&SizeOfExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    214 => listener.exit_stack_alloc_array_creation_expression(&StackAllocArrayCreationExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    215 => listener.exit_switch_expression_arm(&SwitchExpressionArmContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    216 => listener.exit_throw_expression(&ThrowExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    217 => listener.exit_tuple_expression(&TupleExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    218 => listener.exit_type_of_expression(&TypeOfExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    219 => listener.exit_unsafe_expression(&UnsafeExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    220 => listener.exit_syntax_token(&SyntaxTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    221 => listener.exit_identifier_token(&IdentifierTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    222 => listener.exit_keyword(&KeywordContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    223 => listener.exit_numeric_literal_token(&NumericLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    224 => listener.exit_integer_literal_token(&IntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    225 => listener.exit_decimal_integer_literal_token(&DecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    226 => listener.exit_hexadecimal_integer_literal_token(&HexadecimalIntegerLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    227 => listener.exit_real_literal_token(&RealLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    228 => listener.exit_character_literal_token(&CharacterLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    229 => listener.exit_string_literal_token(&StringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    230 => listener.exit_regular_string_literal_token(&RegularStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    231 => listener.exit_verbatim_string_literal_token(&VerbatimStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    232 => listener.exit_operator_token(&OperatorTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    233 => listener.exit_punctuation_token(&PunctuationTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    234 => listener.exit_interpolated_string_text_token(&InterpolatedStringTextTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    235 => listener.exit_multi_line_raw_string_literal_token(&MultiLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    236 => listener.exit_single_line_raw_string_literal_token(&SingleLineRawStringLiteralTokenContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    237 => listener.exit_record_keyword(&RecordKeywordContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    238 => listener.exit_right_shift(&RightShiftContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    239 => listener.exit_unsigned_right_shift(&UnsignedRightShiftContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    240 => listener.exit_right_shift_assignment(&RightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    241 => listener.exit_unsigned_right_shift_assignment(&UnsignedRightShiftAssignmentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    242 => listener.exit_local_variable_declaration(&LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    243 => listener.exit_local_variable_declarator(&LocalVariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        _ => {}
                    }
                    listener.exit_every_rule(ValidatedRuleNode { __node: context })?;
                    if let Some(states) = &mut invocation_states {
                        states.remove(0);
                    }
                }
            }
        }
        Ok(())
    }
}

pub type ValidatedParseTreeWalker = CSharpValidatedTreeWalker;



static PARSER_ATN_DATA: &[u32] = &[1346458702, 2, 16909060, 29, 206, 3140, 4233, 19, 136, 362, 244, 29, 21980, 22009, 21165, 43174, 95, 43269, 272, 43607, 362, 43969, 244, 44213, 244, 44457, 33, 43541, 66, 2, 0, 8, 0, 1, 4294967295, 4294967295, 7, 0, 16, 1, 0, 4294967295, 4294967295, 2, 1, 8, 1, 1, 4294967295, 4294967295, 7, 1, 24, 2, 3, 4294967295, 4294967295, 2, 2, 8, 5, 1, 4294967295, 4294967295, 7, 2, 24, 6, 3, 4294967295, 4294967295, 2, 3, 8, 9, 1, 4294967295, 4294967295, 7, 3, 24, 10, 3, 4294967295, 4294967295, 2, 4, 8, 13, 1, 4294967295, 4294967295, 7, 4, 24, 14, 7, 4294967295, 4294967295, 2, 5, 8, 21, 1, 4294967295, 4294967295, 7, 5, 24, 22, 54, 4294967295, 4294967295, 2, 6, 8, 76, 1, 4294967295, 4294967295, 7, 6, 24, 77, 1, 4294967295, 4294967295, 2, 7, 8, 78, 1, 4294967295, 4294967295, 7, 7, 24, 79, 2, 4294967295, 4294967295, 2, 8, 12, 81, 1, 4294967295, 4294967295, 7, 8, 24, 82, 5, 4294967295, 4294967295, 2, 9, 8, 87, 1, 4294967295, 4294967295, 7, 9, 24, 88, 1, 4294967295, 4294967295, 2, 10, 8, 89, 1, 4294967295, 4294967295, 7, 10, 24, 90, 5, 4294967295, 4294967295, 2, 11, 8, 95, 1, 4294967295, 4294967295, 7, 11, 24, 96, 1, 4294967295, 4294967295, 2, 12, 8, 97, 1, 4294967295, 4294967295, 7, 12, 24, 98, 1, 4294967295, 4294967295, 2, 13, 8, 99, 1, 4294967295, 4294967295, 7, 13, 24, 100, 1, 4294967295, 4294967295, 2, 14, 8, 101, 1, 4294967295, 4294967295, 7, 14, 24, 102, 2, 4294967295, 4294967295, 2, 15, 8, 104, 1, 4294967295, 4294967295, 7, 15, 24, 105, 3, 4294967295, 4294967295, 2, 16, 8, 108, 1, 4294967295, 4294967295, 7, 16, 24, 109, 9, 4294967295, 4294967295, 2, 17, 8, 118, 1, 4294967295, 4294967295, 7, 17, 24, 119, 1, 4294967295, 4294967295, 2, 18, 8, 120, 1, 4294967295, 4294967295, 7, 18, 24, 121, 1, 4294967295, 4294967295, 2, 19, 8, 122, 1, 4294967295, 4294967295, 7, 19, 24, 123, 31, 4294967295, 4294967295, 2, 20, 8, 154, 1, 4294967295, 4294967295, 7, 20, 24, 155, 5, 4294967295, 4294967295, 2, 21, 8, 160, 1, 4294967295, 4294967295, 7, 21, 24, 161, 2, 4294967295, 4294967295, 2, 22, 8, 163, 1, 4294967295, 4294967295, 7, 22, 24, 164, 4, 4294967295, 4294967295, 2, 23, 8, 168, 1, 4294967295, 4294967295, 7, 23, 24, 169, 6, 4294967295, 4294967295, 2, 24, 8, 175, 1, 4294967295, 4294967295, 7, 24, 24, 176, 6, 4294967295, 4294967295, 2, 25, 8, 182, 1, 4294967295, 4294967295, 7, 25, 24, 183, 1, 4294967295, 4294967295, 2, 26, 8, 184, 1, 4294967295, 4294967295, 7, 26, 24, 185, 1, 4294967295, 4294967295, 2, 27, 8, 186, 1, 4294967295, 4294967295, 7, 27, 24, 187, 1, 4294967295, 4294967295, 2, 28, 8, 188, 1, 4294967295, 4294967295, 7, 28, 24, 189, 15, 4294967295, 4294967295, 2, 29, 8, 204, 1, 4294967295, 4294967295, 7, 29, 24, 205, 4, 4294967295, 4294967295, 2, 30, 8, 209, 1, 4294967295, 4294967295, 7, 30, 24, 210, 1, 4294967295, 4294967295, 2, 31, 8, 211, 1, 4294967295, 4294967295, 7, 31, 24, 212, 6, 4294967295, 4294967295, 2, 32, 8, 218, 1, 4294967295, 4294967295, 7, 32, 24, 219, 16, 4294967295, 4294967295, 2, 33, 8, 235, 1, 4294967295, 4294967295, 7, 33, 24, 236, 9, 4294967295, 4294967295, 2, 34, 8, 245, 1, 4294967295, 4294967295, 7, 34, 24, 246, 1, 4294967295, 4294967295, 2, 35, 8, 247, 1, 4294967295, 4294967295, 7, 35, 24, 248, 6, 4294967295, 4294967295, 2, 36, 8, 254, 1, 4294967295, 4294967295, 7, 36, 24, 255, 1, 4294967295, 4294967295, 2, 37, 8, 256, 1, 4294967295, 4294967295, 7, 37, 24, 257, 1, 4294967295, 4294967295, 2, 38, 8, 258, 1, 4294967295, 4294967295, 7, 38, 24, 259, 9, 4294967295, 4294967295, 2, 39, 8, 268, 1, 4294967295, 4294967295, 7, 39, 24, 269, 2, 4294967295, 4294967295, 2, 40, 8, 271, 1, 4294967295, 4294967295, 7, 40, 24, 272, 9, 4294967295, 4294967295, 2, 41, 8, 281, 1, 4294967295, 4294967295, 7, 41, 24, 282, 2, 4294967295, 4294967295, 2, 42, 8, 284, 1, 4294967295, 4294967295, 7, 42, 24, 285, 1, 4294967295, 4294967295, 2, 43, 8, 286, 1, 4294967295, 4294967295, 7, 43, 24, 287, 2, 4294967295, 4294967295, 2, 44, 8, 289, 1, 4294967295, 4294967295, 7, 44, 24, 290, 1, 4294967295, 4294967295, 2, 45, 8, 291, 1, 4294967295, 4294967295, 7, 45, 24, 292, 1, 4294967295, 4294967295, 2, 46, 8, 293, 1, 4294967295, 4294967295, 7, 46, 24, 294, 1, 4294967295, 4294967295, 2, 47, 8, 295, 1, 4294967295, 4294967295, 7, 47, 24, 296, 1, 4294967295, 4294967295, 2, 48, 8, 297, 1, 4294967295, 4294967295, 7, 48, 24, 298, 1, 4294967295, 4294967295, 2, 49, 8, 299, 1, 4294967295, 4294967295, 7, 49, 24, 300, 1, 4294967295, 4294967295, 2, 50, 8, 301, 1, 4294967295, 4294967295, 7, 50, 24, 302, 1, 4294967295, 4294967295, 2, 51, 8, 303, 1, 4294967295, 4294967295, 7, 51, 24, 304, 1, 4294967295, 4294967295, 2, 52, 8, 305, 1, 4294967295, 4294967295, 7, 52, 24, 306, 1, 4294967295, 4294967295, 2, 53, 8, 307, 1, 4294967295, 4294967295, 7, 53, 24, 308, 1, 4294967295, 4294967295, 2, 54, 8, 309, 1, 4294967295, 4294967295, 7, 54, 24, 310, 1, 4294967295, 4294967295, 2, 55, 8, 311, 1, 4294967295, 4294967295, 7, 55, 24, 312, 3, 4294967295, 4294967295, 2, 56, 8, 315, 1, 4294967295, 4294967295, 7, 56, 24, 316, 1, 4294967295, 4294967295, 2, 57, 8, 317, 1, 4294967295, 4294967295, 7, 57, 24, 318, 1, 4294967295, 4294967295, 2, 58, 8, 319, 1, 4294967295, 4294967295, 7, 58, 24, 320, 1, 4294967295, 4294967295, 2, 59, 8, 321, 1, 4294967295, 4294967295, 7, 59, 24, 322, 1, 4294967295, 4294967295, 2, 60, 8, 323, 1, 4294967295, 4294967295, 7, 60, 24, 324, 1, 4294967295, 4294967295, 2, 61, 8, 325, 1, 4294967295, 4294967295, 7, 61, 24, 326, 1, 4294967295, 4294967295, 2, 62, 8, 327, 1, 4294967295, 4294967295, 7, 62, 24, 328, 6, 4294967295, 4294967295, 2, 63, 8, 334, 1, 4294967295, 4294967295, 7, 63, 24, 335, 2, 4294967295, 4294967295, 2, 64, 8, 337, 1, 4294967295, 4294967295, 7, 64, 24, 338, 1, 4294967295, 4294967295, 2, 65, 8, 339, 1, 4294967295, 4294967295, 7, 65, 24, 340, 1, 4294967295, 4294967295, 2, 66, 8, 341, 1, 4294967295, 4294967295, 7, 66, 24, 342, 3, 4294967295, 4294967295, 2, 67, 8, 345, 1, 4294967295, 4294967295, 7, 67, 24, 346, 1, 4294967295, 4294967295, 2, 68, 8, 347, 1, 4294967295, 4294967295, 7, 68, 24, 348, 1, 4294967295, 4294967295, 2, 69, 8, 349, 1, 4294967295, 4294967295, 7, 69, 24, 350, 2, 4294967295, 4294967295, 2, 70, 8, 352, 1, 4294967295, 4294967295, 7, 70, 24, 353, 1, 4294967295, 4294967295, 2, 71, 8, 354, 1, 4294967295, 4294967295, 7, 71, 24, 355, 2, 4294967295, 4294967295, 2, 72, 8, 357, 1, 4294967295, 4294967295, 7, 72, 24, 358, 1, 4294967295, 4294967295, 2, 73, 8, 359, 1, 4294967295, 4294967295, 7, 73, 24, 360, 2, 4294967295, 4294967295, 2, 74, 8, 362, 1, 4294967295, 4294967295, 7, 74, 24, 363, 1, 4294967295, 4294967295, 2, 75, 8, 364, 1, 4294967295, 4294967295, 7, 75, 24, 365, 1, 4294967295, 4294967295, 2, 76, 12, 366, 1, 4294967295, 4294967295, 7, 76, 24, 367, 39, 4294967295, 4294967295, 2, 77, 8, 406, 1, 4294967295, 4294967295, 7, 77, 24, 407, 1, 4294967295, 4294967295, 2, 78, 8, 408, 1, 4294967295, 4294967295, 7, 78, 24, 409, 2, 4294967295, 4294967295, 2, 79, 8, 411, 1, 4294967295, 4294967295, 7, 79, 24, 412, 1, 4294967295, 4294967295, 2, 80, 8, 413, 1, 4294967295, 4294967295, 7, 80, 24, 414, 1, 4294967295, 4294967295, 2, 81, 8, 415, 1, 4294967295, 4294967295, 7, 81, 24, 416, 2, 4294967295, 4294967295, 2, 82, 8, 418, 1, 4294967295, 4294967295, 7, 82, 24, 419, 2, 4294967295, 4294967295, 2, 83, 8, 421, 1, 4294967295, 4294967295, 7, 83, 24, 422, 1, 4294967295, 4294967295, 2, 84, 8, 423, 1, 4294967295, 4294967295, 7, 84, 24, 424, 2, 4294967295, 4294967295, 2, 85, 8, 426, 1, 4294967295, 4294967295, 7, 85, 24, 427, 1, 4294967295, 4294967295, 2, 86, 8, 428, 1, 4294967295, 4294967295, 7, 86, 24, 429, 1, 4294967295, 4294967295, 2, 87, 8, 430, 1, 4294967295, 4294967295, 7, 87, 24, 431, 1, 4294967295, 4294967295, 2, 88, 8, 432, 1, 4294967295, 4294967295, 7, 88, 24, 433, 1, 4294967295, 4294967295, 2, 89, 8, 434, 1, 4294967295, 4294967295, 7, 89, 24, 435, 2, 4294967295, 4294967295, 2, 90, 8, 437, 1, 4294967295, 4294967295, 7, 90, 24, 438, 14, 4294967295, 4294967295, 2, 91, 8, 452, 1, 4294967295, 4294967295, 7, 91, 24, 453, 1, 4294967295, 4294967295, 2, 92, 8, 454, 1, 4294967295, 4294967295, 7, 92, 24, 455, 1, 4294967295, 4294967295, 2, 93, 8, 456, 1, 4294967295, 4294967295, 7, 93, 24, 457, 1, 4294967295, 4294967295, 2, 94, 8, 458, 1, 4294967295, 4294967295, 7, 94, 24, 459, 1, 4294967295, 4294967295, 2, 95, 8, 460, 1, 4294967295, 4294967295, 7, 95, 24, 461, 1, 4294967295, 4294967295, 2, 96, 8, 462, 1, 4294967295, 4294967295, 7, 96, 24, 463, 1, 4294967295, 4294967295, 2, 97, 8, 464, 1, 4294967295, 4294967295, 7, 97, 24, 465, 1, 4294967295, 4294967295, 2, 98, 8, 466, 1, 4294967295, 4294967295, 7, 98, 24, 467, 1, 4294967295, 4294967295, 2, 99, 8, 468, 1, 4294967295, 4294967295, 7, 99, 24, 469, 1, 4294967295, 4294967295, 2, 100, 8, 470, 1, 4294967295, 4294967295, 7, 100, 24, 471, 1, 4294967295, 4294967295, 2, 101, 8, 472, 1, 4294967295, 4294967295, 7, 101, 24, 473, 1, 4294967295, 4294967295, 2, 102, 8, 474, 1, 4294967295, 4294967295, 7, 102, 24, 475, 1, 4294967295, 4294967295, 2, 103, 8, 476, 1, 4294967295, 4294967295, 7, 103, 24, 477, 1, 4294967295, 4294967295, 2, 104, 8, 478, 1, 4294967295, 4294967295, 7, 104, 24, 479, 1, 4294967295, 4294967295, 2, 105, 8, 480, 1, 4294967295, 4294967295, 7, 105, 24, 481, 1, 4294967295, 4294967295, 2, 106, 8, 482, 1, 4294967295, 4294967295, 7, 106, 24, 483, 1, 4294967295, 4294967295, 2, 107, 8, 484, 1, 4294967295, 4294967295, 7, 107, 24, 485, 1, 4294967295, 4294967295, 2, 108, 8, 486, 1, 4294967295, 4294967295, 7, 108, 24, 487, 1, 4294967295, 4294967295, 2, 109, 8, 488, 1, 4294967295, 4294967295, 7, 109, 24, 489, 1, 4294967295, 4294967295, 2, 110, 8, 490, 1, 4294967295, 4294967295, 7, 110, 24, 491, 1, 4294967295, 4294967295, 2, 111, 8, 492, 1, 4294967295, 4294967295, 7, 111, 24, 493, 1, 4294967295, 4294967295, 2, 112, 8, 494, 1, 4294967295, 4294967295, 7, 112, 24, 495, 1, 4294967295, 4294967295, 2, 113, 8, 496, 1, 4294967295, 4294967295, 7, 113, 24, 497, 1, 4294967295, 4294967295, 2, 114, 12, 498, 1, 4294967295, 4294967295, 7, 114, 24, 499, 10, 4294967295, 4294967295, 2, 115, 8, 509, 1, 4294967295, 4294967295, 7, 115, 24, 510, 1, 4294967295, 4294967295, 2, 116, 8, 511, 1, 4294967295, 4294967295, 7, 116, 24, 512, 1, 4294967295, 4294967295, 2, 117, 8, 513, 1, 4294967295, 4294967295, 7, 117, 24, 514, 7, 4294967295, 4294967295, 2, 118, 8, 521, 1, 4294967295, 4294967295, 7, 118, 24, 522, 1, 4294967295, 4294967295, 2, 119, 8, 523, 1, 4294967295, 4294967295, 7, 119, 24, 524, 1, 4294967295, 4294967295, 2, 120, 8, 525, 1, 4294967295, 4294967295, 7, 120, 24, 526, 1, 4294967295, 4294967295, 2, 121, 8, 527, 1, 4294967295, 4294967295, 7, 121, 24, 528, 1, 4294967295, 4294967295, 2, 122, 8, 529, 1, 4294967295, 4294967295, 7, 122, 24, 530, 1, 4294967295, 4294967295, 2, 123, 8, 531, 1, 4294967295, 4294967295, 7, 123, 24, 532, 1, 4294967295, 4294967295, 2, 124, 8, 533, 1, 4294967295, 4294967295, 7, 124, 24, 534, 1, 4294967295, 4294967295, 2, 125, 8, 535, 1, 4294967295, 4294967295, 7, 125, 24, 536, 1, 4294967295, 4294967295, 2, 126, 8, 537, 1, 4294967295, 4294967295, 7, 126, 24, 538, 4, 4294967295, 4294967295, 2, 127, 8, 542, 1, 4294967295, 4294967295, 7, 127, 24, 543, 1, 4294967295, 4294967295, 2, 128, 8, 544, 1, 4294967295, 4294967295, 7, 128, 24, 545, 1, 4294967295, 4294967295, 2, 129, 8, 546, 1, 4294967295, 4294967295, 7, 129, 24, 547, 1, 4294967295, 4294967295, 2, 130, 8, 548, 1, 4294967295, 4294967295, 7, 130, 24, 549, 1, 4294967295, 4294967295, 2, 131, 8, 550, 1, 4294967295, 4294967295, 7, 131, 24, 551, 1, 4294967295, 4294967295, 2, 132, 8, 552, 1, 4294967295, 4294967295, 7, 132, 24, 553, 1, 4294967295, 4294967295, 2, 133, 8, 554, 1, 4294967295, 4294967295, 7, 133, 24, 555, 1, 4294967295, 4294967295, 2, 134, 8, 556, 1, 4294967295, 4294967295, 7, 134, 24, 557, 1, 4294967295, 4294967295, 2, 135, 8, 558, 1, 4294967295, 4294967295, 7, 135, 24, 559, 2, 4294967295, 4294967295, 2, 136, 8, 561, 1, 4294967295, 4294967295, 7, 136, 24, 562, 1, 4294967295, 4294967295, 2, 137, 8, 563, 1, 4294967295, 4294967295, 7, 137, 24, 564, 1, 4294967295, 4294967295, 2, 138, 8, 565, 1, 4294967295, 4294967295, 7, 138, 24, 566, 1, 4294967295, 4294967295, 2, 139, 8, 567, 1, 4294967295, 4294967295, 7, 139, 24, 568, 1, 4294967295, 4294967295, 2, 140, 8, 569, 1, 4294967295, 4294967295, 7, 140, 24, 570, 1, 4294967295, 4294967295, 2, 141, 8, 571, 1, 4294967295, 4294967295, 7, 141, 24, 572, 1, 4294967295, 4294967295, 2, 142, 8, 573, 1, 4294967295, 4294967295, 7, 142, 24, 574, 1, 4294967295, 4294967295, 2, 143, 8, 575, 1, 4294967295, 4294967295, 7, 143, 24, 576, 1, 4294967295, 4294967295, 2, 144, 8, 577, 1, 4294967295, 4294967295, 7, 144, 24, 578, 1, 4294967295, 4294967295, 2, 145, 8, 579, 1, 4294967295, 4294967295, 7, 145, 24, 580, 1, 4294967295, 4294967295, 2, 146, 8, 581, 1, 4294967295, 4294967295, 7, 146, 24, 582, 1, 4294967295, 4294967295, 2, 147, 8, 583, 1, 4294967295, 4294967295, 7, 147, 24, 584, 1, 4294967295, 4294967295, 2, 148, 12, 585, 1, 4294967295, 4294967295, 7, 148, 24, 586, 69, 4294967295, 4294967295, 2, 149, 8, 655, 1, 4294967295, 4294967295, 7, 149, 24, 656, 1, 4294967295, 4294967295, 2, 150, 8, 657, 1, 4294967295, 4294967295, 7, 150, 24, 658, 1, 4294967295, 4294967295, 2, 151, 8, 659, 1, 4294967295, 4294967295, 7, 151, 24, 660, 1, 4294967295, 4294967295, 2, 152, 8, 661, 1, 4294967295, 4294967295, 7, 152, 24, 662, 1, 4294967295, 4294967295, 2, 153, 8, 663, 1, 4294967295, 4294967295, 7, 153, 24, 664, 1, 4294967295, 4294967295, 2, 154, 8, 665, 1, 4294967295, 4294967295, 7, 154, 24, 666, 1, 4294967295, 4294967295, 2, 155, 8, 667, 1, 4294967295, 4294967295, 7, 155, 24, 668, 2, 4294967295, 4294967295, 2, 156, 8, 670, 1, 4294967295, 4294967295, 7, 156, 24, 671, 1, 4294967295, 4294967295, 2, 157, 8, 672, 1, 4294967295, 4294967295, 7, 157, 24, 673, 8, 4294967295, 4294967295, 2, 158, 8, 681, 1, 4294967295, 4294967295, 7, 158, 24, 682, 1, 4294967295, 4294967295, 2, 159, 8, 683, 1, 4294967295, 4294967295, 7, 159, 24, 684, 1, 4294967295, 4294967295, 2, 160, 8, 685, 1, 4294967295, 4294967295, 7, 160, 24, 686, 1, 4294967295, 4294967295, 2, 161, 8, 687, 1, 4294967295, 4294967295, 7, 161, 24, 688, 1, 4294967295, 4294967295, 2, 162, 8, 689, 1, 4294967295, 4294967295, 7, 162, 24, 690, 1, 4294967295, 4294967295, 2, 163, 8, 691, 1, 4294967295, 4294967295, 7, 163, 24, 692, 1, 4294967295, 4294967295, 2, 164, 8, 693, 1, 4294967295, 4294967295, 7, 164, 24, 694, 1, 4294967295, 4294967295, 2, 165, 8, 695, 1, 4294967295, 4294967295, 7, 165, 24, 696, 2, 4294967295, 4294967295, 2, 166, 8, 698, 1, 4294967295, 4294967295, 7, 166, 24, 699, 1, 4294967295, 4294967295, 2, 167, 8, 700, 1, 4294967295, 4294967295, 7, 167, 24, 701, 1, 4294967295, 4294967295, 2, 168, 8, 702, 1, 4294967295, 4294967295, 7, 168, 24, 703, 1, 4294967295, 4294967295, 2, 169, 8, 704, 1, 4294967295, 4294967295, 7, 169, 24, 705, 1, 4294967295, 4294967295, 2, 170, 8, 706, 1, 4294967295, 4294967295, 7, 170, 24, 707, 1, 4294967295, 4294967295, 2, 171, 8, 708, 1, 4294967295, 4294967295, 7, 171, 24, 709, 1, 4294967295, 4294967295, 2, 172, 8, 710, 1, 4294967295, 4294967295, 7, 172, 24, 711, 1, 4294967295, 4294967295, 2, 173, 8, 712, 1, 4294967295, 4294967295, 7, 173, 24, 713, 1, 4294967295, 4294967295, 2, 174, 8, 714, 1, 4294967295, 4294967295, 7, 174, 24, 715, 1, 4294967295, 4294967295, 2, 175, 8, 716, 1, 4294967295, 4294967295, 7, 175, 24, 717, 1, 4294967295, 4294967295, 2, 176, 8, 718, 1, 4294967295, 4294967295, 7, 176, 24, 719, 1, 4294967295, 4294967295, 2, 177, 8, 720, 1, 4294967295, 4294967295, 7, 177, 24, 721, 1, 4294967295, 4294967295, 2, 178, 8, 722, 1, 4294967295, 4294967295, 7, 178, 24, 723, 1, 4294967295, 4294967295, 2, 179, 8, 724, 1, 4294967295, 4294967295, 7, 179, 24, 725, 1, 4294967295, 4294967295, 2, 180, 8, 726, 1, 4294967295, 4294967295, 7, 180, 24, 727, 4, 4294967295, 4294967295, 2, 181, 8, 731, 1, 4294967295, 4294967295, 7, 181, 24, 732, 1, 4294967295, 4294967295, 2, 182, 8, 733, 1, 4294967295, 4294967295, 7, 182, 24, 734, 1, 4294967295, 4294967295, 2, 183, 8, 735, 1, 4294967295, 4294967295, 7, 183, 24, 736, 1, 4294967295, 4294967295, 2, 184, 8, 737, 1, 4294967295, 4294967295, 7, 184, 24, 738, 1, 4294967295, 4294967295, 2, 185, 8, 739, 1, 4294967295, 4294967295, 7, 185, 24, 740, 1, 4294967295, 4294967295, 2, 186, 8, 741, 1, 4294967295, 4294967295, 7, 186, 24, 742, 2, 4294967295, 4294967295, 2, 187, 8, 744, 1, 4294967295, 4294967295, 7, 187, 24, 745, 1, 4294967295, 4294967295, 2, 188, 8, 746, 1, 4294967295, 4294967295, 7, 188, 24, 747, 1, 4294967295, 4294967295, 2, 189, 8, 748, 1, 4294967295, 4294967295, 7, 189, 24, 749, 1, 4294967295, 4294967295, 2, 190, 8, 750, 1, 4294967295, 4294967295, 7, 190, 24, 751, 1, 4294967295, 4294967295, 2, 191, 8, 752, 1, 4294967295, 4294967295, 7, 191, 24, 753, 1, 4294967295, 4294967295, 2, 192, 8, 754, 1, 4294967295, 4294967295, 7, 192, 24, 755, 1, 4294967295, 4294967295, 2, 193, 8, 756, 1, 4294967295, 4294967295, 7, 193, 24, 757, 1, 4294967295, 4294967295, 2, 194, 8, 758, 1, 4294967295, 4294967295, 7, 194, 24, 759, 1, 4294967295, 4294967295, 2, 195, 8, 760, 1, 4294967295, 4294967295, 7, 195, 24, 761, 1, 4294967295, 4294967295, 2, 196, 8, 762, 1, 4294967295, 4294967295, 7, 196, 24, 763, 1, 4294967295, 4294967295, 2, 197, 8, 764, 1, 4294967295, 4294967295, 7, 197, 24, 765, 2, 4294967295, 4294967295, 2, 198, 8, 767, 1, 4294967295, 4294967295, 7, 198, 24, 768, 2, 4294967295, 4294967295, 2, 199, 8, 770, 1, 4294967295, 4294967295, 7, 199, 24, 771, 1, 4294967295, 4294967295, 2, 200, 8, 772, 1, 4294967295, 4294967295, 7, 200, 24, 773, 1, 4294967295, 4294967295, 2, 201, 8, 774, 1, 4294967295, 4294967295, 7, 201, 24, 775, 1, 4294967295, 4294967295, 2, 202, 8, 776, 1, 4294967295, 4294967295, 7, 202, 24, 777, 1, 4294967295, 4294967295, 2, 203, 8, 778, 1, 4294967295, 4294967295, 7, 203, 24, 779, 1, 4294967295, 4294967295, 2, 204, 8, 780, 1, 4294967295, 4294967295, 7, 204, 24, 781, 2, 4294967295, 4294967295, 2, 205, 8, 783, 1, 4294967295, 4294967295, 7, 205, 24, 784, 1, 4294967295, 4294967295, 2, 206, 8, 785, 1, 4294967295, 4294967295, 7, 206, 24, 786, 1, 4294967295, 4294967295, 2, 207, 8, 787, 1, 4294967295, 4294967295, 7, 207, 24, 788, 1, 4294967295, 4294967295, 2, 208, 8, 789, 1, 4294967295, 4294967295, 7, 208, 24, 790, 1, 4294967295, 4294967295, 2, 209, 8, 791, 1, 4294967295, 4294967295, 7, 209, 24, 792, 1, 4294967295, 4294967295, 2, 210, 8, 793, 1, 4294967295, 4294967295, 7, 210, 24, 794, 1, 4294967295, 4294967295, 2, 211, 8, 795, 1, 4294967295, 4294967295, 7, 211, 24, 796, 1, 4294967295, 4294967295, 2, 212, 8, 797, 1, 4294967295, 4294967295, 7, 212, 24, 798, 1, 4294967295, 4294967295, 2, 213, 8, 799, 1, 4294967295, 4294967295, 7, 213, 24, 800, 1, 4294967295, 4294967295, 2, 214, 8, 801, 1, 4294967295, 4294967295, 7, 214, 24, 802, 1, 4294967295, 4294967295, 2, 215, 8, 803, 1, 4294967295, 4294967295, 7, 215, 24, 804, 2, 4294967295, 4294967295, 2, 216, 8, 806, 1, 4294967295, 4294967295, 7, 216, 24, 807, 1, 4294967295, 4294967295, 2, 217, 8, 808, 1, 4294967295, 4294967295, 7, 217, 24, 809, 1, 4294967295, 4294967295, 2, 218, 8, 810, 1, 4294967295, 4294967295, 7, 218, 24, 811, 1, 4294967295, 4294967295, 2, 219, 8, 812, 1, 4294967295, 4294967295, 7, 219, 24, 813, 1, 4294967295, 4294967295, 2, 220, 8, 814, 1, 4294967295, 4294967295, 7, 220, 24, 815, 1, 4294967295, 4294967295, 2, 221, 8, 816, 1, 4294967295, 4294967295, 7, 221, 24, 817, 33, 4294967295, 4294967295, 2, 222, 8, 850, 1, 4294967295, 4294967295, 7, 222, 24, 851, 1, 4294967295, 4294967295, 2, 223, 8, 852, 1, 4294967295, 4294967295, 7, 223, 24, 853, 2, 4294967295, 4294967295, 2, 224, 8, 855, 1, 4294967295, 4294967295, 7, 224, 24, 856, 1, 4294967295, 4294967295, 2, 225, 8, 857, 1, 4294967295, 4294967295, 7, 225, 24, 858, 1, 4294967295, 4294967295, 2, 226, 8, 859, 1, 4294967295, 4294967295, 7, 226, 24, 860, 1, 4294967295, 4294967295, 2, 227, 8, 861, 1, 4294967295, 4294967295, 7, 227, 24, 862, 1, 4294967295, 4294967295, 2, 228, 8, 863, 1, 4294967295, 4294967295, 7, 228, 24, 864, 2, 4294967295, 4294967295, 2, 229, 8, 866, 1, 4294967295, 4294967295, 7, 229, 24, 867, 3, 4294967295, 4294967295, 2, 230, 8, 870, 1, 4294967295, 4294967295, 7, 230, 24, 871, 1, 4294967295, 4294967295, 2, 231, 8, 872, 1, 4294967295, 4294967295, 7, 231, 24, 873, 1, 4294967295, 4294967295, 2, 232, 8, 874, 1, 4294967295, 4294967295, 7, 232, 24, 875, 1, 4294967295, 4294967295, 2, 233, 8, 876, 1, 4294967295, 4294967295, 7, 233, 24, 877, 1, 4294967295, 4294967295, 2, 234, 8, 878, 1, 4294967295, 4294967295, 7, 234, 24, 879, 2, 4294967295, 4294967295, 2, 235, 8, 881, 1, 4294967295, 4294967295, 7, 235, 24, 882, 2, 4294967295, 4294967295, 2, 236, 8, 884, 1, 4294967295, 4294967295, 7, 236, 24, 885, 2, 4294967295, 4294967295, 2, 237, 8, 887, 1, 4294967295, 4294967295, 7, 237, 24, 888, 1, 4294967295, 4294967295, 2, 238, 8, 889, 1, 4294967295, 4294967295, 7, 238, 24, 890, 3, 4294967295, 4294967295, 2, 239, 8, 893, 1, 4294967295, 4294967295, 7, 239, 24, 894, 3, 4294967295, 4294967295, 2, 240, 8, 897, 1, 4294967295, 4294967295, 7, 240, 24, 898, 3, 4294967295, 4294967295, 2, 241, 8, 901, 1, 4294967295, 4294967295, 7, 241, 24, 902, 3, 4294967295, 4294967295, 2, 242, 8, 905, 1, 4294967295, 4294967295, 7, 242, 24, 906, 1, 4294967295, 4294967295, 2, 243, 8, 907, 1, 4294967295, 4294967295, 7, 243, 24, 908, 2, 4294967295, 4294967295, 1, 0, 8, 910, 1, 4294967295, 4294967295, 5, 0, 8, 911, 1, 490, 4294967295, 8, 0, 8, 912, 1, 4294967295, 4294967295, 10, 0, 8, 913, 2, 4294967295, 4294967295, 12, 0, 8, 915, 1, 4294967295, 493, 9, 0, 8, 916, 1, 4294967295, 4294967295, 1, 0, 8, 917, 1, 4294967295, 4294967295, 5, 0, 8, 918, 1, 496, 4294967295, 8, 0, 8, 919, 1, 4294967295, 4294967295, 10, 0, 8, 920, 2, 4294967295, 4294967295, 12, 0, 8, 922, 1, 4294967295, 499, 9, 0, 8, 923, 1, 4294967295, 4294967295, 1, 0, 8, 924, 1, 4294967295, 4294967295, 5, 0, 8, 925, 1, 502, 4294967295, 8, 0, 8, 926, 1, 4294967295, 4294967295, 10, 0, 8, 927, 2, 4294967295, 4294967295, 12, 0, 8, 929, 1, 4294967295, 505, 9, 0, 8, 930, 1, 4294967295, 4294967295, 1, 0, 8, 931, 1, 4294967295, 4294967295, 5, 0, 8, 932, 1, 508, 4294967295, 8, 0, 8, 933, 1, 4294967295, 4294967295, 10, 0, 8, 934, 2, 4294967295, 4294967295, 12, 0, 8, 936, 1, 4294967295, 511, 9, 0, 8, 937, 1, 4294967295, 4294967295, 1, 0, 32, 938, 1, 4294967295, 4294967295, 1, 0, 8, 939, 1, 4294967295, 4294967295, 1, 1, 32, 940, 1, 4294967295, 4294967295, 1, 1, 32, 941, 1, 4294967295, 4294967295, 1, 1, 8, 942, 1, 4294967295, 4294967295, 1, 1, 32, 943, 1, 4294967295, 4294967295, 1, 1, 8, 944, 1, 4294967295, 4294967295, 1, 2, 32, 945, 1, 4294967295, 4294967295, 3, 2, 8, 946, 2, 521, 4294967295, 8, 2, 8, 948, 1, 4294967295, 4294967295, 1, 2, 32, 949, 1, 4294967295, 4294967295, 1, 2, 32, 950, 1, 4294967295, 4294967295, 1, 2, 32, 951, 1, 4294967295, 4294967295, 3, 2, 8, 952, 2, 526, 4294967295, 8, 2, 8, 954, 1, 4294967295, 4294967295, 1, 2, 8, 955, 1, 4294967295, 4294967295, 3, 2, 8, 956, 3, 529, 4294967295, 8, 2, 8, 959, 1, 4294967295, 4294967295, 1, 2, 8, 960, 1, 4294967295, 4294967295, 1, 2, 32, 961, 1, 4294967295, 4294967295, 1, 2, 8, 962, 1, 4294967295, 4294967295, 1, 3, 8, 963, 1, 4294967295, 4294967295, 1, 3, 32, 964, 1, 4294967295, 4294967295, 1, 3, 8, 965, 1, 4294967295, 4294967295, 1, 4, 32, 966, 1, 4294967295, 4294967295, 1, 4, 8, 967, 1, 4294967295, 4294967295, 3, 4, 8, 968, 2, 539, 4294967295, 8, 4, 8, 970, 1, 4294967295, 4294967295, 1, 5, 32, 971, 1, 4294967295, 4294967295, 1, 5, 8, 972, 1, 4294967295, 4294967295, 3, 5, 8, 973, 2, 543, 4294967295, 8, 5, 8, 975, 1, 4294967295, 4294967295, 1, 5, 8, 976, 1, 4294967295, 4294967295, 1, 5, 32, 977, 1, 4294967295, 4294967295, 1, 5, 8, 978, 1, 4294967295, 4294967295, 5, 5, 8, 979, 1, 548, 4294967295, 8, 5, 8, 980, 1, 4294967295, 4294967295, 10, 5, 8, 981, 2, 4294967295, 4294967295, 12, 5, 8, 983, 1, 4294967295, 551, 9, 5, 8, 984, 1, 4294967295, 4294967295, 1, 5, 32, 985, 1, 4294967295, 4294967295, 1, 5, 8, 986, 1, 4294967295, 4294967295, 1, 6, 8, 987, 1, 4294967295, 4294967295, 1, 6, 32, 988, 1, 4294967295, 4294967295, 1, 6, 8, 989, 1, 4294967295, 4294967295, 1, 7, 8, 990, 1, 4294967295, 4294967295, 1, 7, 8, 991, 1, 4294967295, 4294967295, 3, 7, 8, 992, 2, 560, 4294967295, 8, 7, 8, 994, 1, 4294967295, 4294967295, 1, 8, 72, 995, 1, 4294967295, 4294967295, 1, 8, 8, 996, 1, 4294967295, 4294967295, 1, 8, 8, 997, 1, 4294967295, 4294967295, 3, 8, 8, 998, 2, 565, 4294967295, 8, 8, 8, 1000, 1, 4294967295, 4294967295, 1, 8, 72, 1001, 1, 4294967295, 4294967295, 1, 8, 32, 1002, 1, 4294967295, 4294967295, 1, 8, 8, 1003, 1, 4294967295, 4294967295, 5, 8, 8, 1004, 1, 570, 4294967295, 8, 8, 8, 1005, 1, 4294967295, 4294967295, 10, 8, 10, 1006, 2, 4294967295, 4294967295, 12, 8, 8, 1008, 1, 4294967295, 573, 9, 8, 8, 1009, 1, 4294967295, 4294967295, 1, 9, 8, 1010, 1, 4294967295, 4294967295, 1, 9, 32, 1011, 1, 4294967295, 4294967295, 1, 9, 8, 1012, 1, 4294967295, 4294967295, 1, 9, 8, 1013, 1, 4294967295, 4294967295, 1, 10, 8, 1014, 1, 4294967295, 4294967295, 1, 10, 8, 1015, 1, 4294967295, 4294967295, 3, 10, 8, 1016, 2, 581, 4294967295, 8, 10, 8, 1018, 1, 4294967295, 4294967295, 1, 11, 8, 1019, 1, 4294967295, 4294967295, 1, 11, 8, 1020, 1, 4294967295, 4294967295, 1, 11, 8, 1021, 1, 4294967295, 4294967295, 1, 12, 32, 1022, 1, 4294967295, 4294967295, 1, 12, 8, 1023, 1, 4294967295, 4294967295, 3, 12, 8, 1024, 2, 588, 4294967295, 8, 12, 8, 1026, 1, 4294967295, 4294967295, 1, 12, 32, 1027, 1, 4294967295, 4294967295, 1, 12, 8, 1028, 1, 4294967295, 4294967295, 3, 12, 8, 1029, 2, 592, 4294967295, 8, 12, 8, 1031, 1, 4294967295, 4294967295, 5, 12, 8, 1032, 1, 594, 4294967295, 8, 12, 8, 1033, 1, 4294967295, 4294967295, 10, 12, 8, 1034, 2, 4294967295, 4294967295, 12, 12, 8, 1036, 1, 4294967295, 597, 9, 12, 8, 1037, 1, 4294967295, 4294967295, 3, 12, 8, 1038, 2, 599, 4294967295, 8, 12, 8, 1040, 1, 4294967295, 4294967295, 1, 12, 32, 1041, 1, 4294967295, 4294967295, 1, 12, 8, 1042, 1, 4294967295, 4294967295, 1, 13, 32, 1043, 1, 4294967295, 4294967295, 1, 13, 8, 1044, 1, 4294967295, 4294967295, 1, 13, 32, 1045, 1, 4294967295, 4294967295, 1, 13, 8, 1046, 1, 4294967295, 4294967295, 5, 13, 8, 1047, 1, 607, 4294967295, 8, 13, 8, 1048, 1, 4294967295, 4294967295, 10, 13, 8, 1049, 2, 4294967295, 4294967295, 12, 13, 8, 1051, 1, 4294967295, 610, 9, 13, 8, 1052, 1, 4294967295, 4294967295, 3, 13, 8, 1053, 2, 612, 4294967295, 8, 13, 8, 1055, 1, 4294967295, 4294967295, 1, 13, 32, 1056, 1, 4294967295, 4294967295, 1, 13, 8, 1057, 1, 4294967295, 4294967295, 1, 14, 8, 1058, 1, 4294967295, 4294967295, 3, 14, 8, 1059, 2, 617, 4294967295, 8, 14, 8, 1061, 1, 4294967295, 4294967295, 1, 14, 8, 1062, 1, 4294967295, 4294967295, 3, 14, 8, 1063, 2, 620, 4294967295, 8, 14, 8, 1065, 1, 4294967295, 4294967295, 3, 14, 8, 1066, 2, 622, 4294967295, 8, 14, 8, 1068, 1, 4294967295, 4294967295, 1, 14, 8, 1069, 1, 4294967295, 4294967295, 1, 14, 8, 1070, 1, 4294967295, 4294967295, 1, 15, 8, 1071, 1, 4294967295, 4294967295, 1, 15, 32, 1072, 1, 4294967295, 4294967295, 1, 15, 8, 1073, 1, 4294967295, 4294967295, 1, 16, 8, 1074, 1, 4294967295, 4294967295, 1, 16, 8, 1075, 1, 4294967295, 4294967295, 1, 16, 8, 1076, 1, 4294967295, 4294967295, 1, 16, 8, 1077, 1, 4294967295, 4294967295, 1, 16, 8, 1078, 1, 4294967295, 4294967295, 1, 16, 8, 1079, 1, 4294967295, 4294967295, 1, 16, 8, 1080, 1, 4294967295, 4294967295, 1, 16, 8, 1081, 1, 4294967295, 4294967295, 1, 16, 8, 1082, 1, 4294967295, 4294967295, 1, 16, 8, 1083, 1, 4294967295, 4294967295, 1, 16, 8, 1084, 1, 4294967295, 4294967295, 3, 16, 8, 1085, 11, 640, 4294967295, 8, 16, 8, 1096, 1, 4294967295, 4294967295, 1, 17, 8, 1097, 1, 4294967295, 4294967295, 1, 17, 8, 1098, 1, 4294967295, 4294967295, 3, 17, 8, 1099, 2, 644, 4294967295, 8, 17, 8, 1101, 1, 4294967295, 4294967295, 1, 18, 8, 1102, 1, 4294967295, 4294967295, 5, 18, 8, 1103, 1, 647, 4294967295, 8, 18, 8, 1104, 1, 4294967295, 4294967295, 10, 18, 8, 1105, 2, 4294967295, 4294967295, 12, 18, 8, 1107, 1, 4294967295, 650, 9, 18, 8, 1108, 1, 4294967295, 4294967295, 1, 18, 8, 1109, 1, 4294967295, 4294967295, 5, 18, 8, 1110, 1, 653, 4294967295, 8, 18, 8, 1111, 1, 4294967295, 4294967295, 10, 18, 8, 1112, 2, 4294967295, 4294967295, 12, 18, 8, 1114, 1, 4294967295, 656, 9, 18, 8, 1115, 1, 4294967295, 4294967295, 1, 18, 32, 1116, 1, 4294967295, 4294967295, 1, 18, 8, 1117, 1, 4294967295, 4294967295, 1, 18, 32, 1118, 1, 4294967295, 4294967295, 1, 18, 8, 1119, 1, 4294967295, 4294967295, 1, 19, 32, 1120, 1, 4294967295, 4294967295, 1, 19, 8, 1121, 1, 4294967295, 4294967295, 1, 20, 8, 1122, 1, 4294967295, 4294967295, 1, 20, 8, 1123, 1, 4294967295, 4294967295, 1, 20, 32, 1124, 1, 4294967295, 4294967295, 1, 20, 8, 1125, 1, 4294967295, 4294967295, 5, 20, 8, 1126, 1, 668, 4294967295, 8, 20, 8, 1127, 1, 4294967295, 4294967295, 10, 20, 8, 1128, 2, 4294967295, 4294967295, 12, 20, 8, 1130, 1, 4294967295, 671, 9, 20, 8, 1131, 1, 4294967295, 4294967295, 1, 21, 8, 1132, 1, 4294967295, 4294967295, 1, 21, 8, 1133, 1, 4294967295, 4294967295, 3, 21, 8, 1134, 2, 675, 4294967295, 8, 21, 8, 1136, 1, 4294967295, 4294967295, 1, 21, 8, 1137, 1, 4294967295, 4294967295, 3, 21, 8, 1138, 2, 678, 4294967295, 8, 21, 8, 1140, 1, 4294967295, 4294967295, 1, 22, 32, 1141, 1, 4294967295, 4294967295, 1, 22, 8, 1142, 1, 4294967295, 4294967295, 1, 22, 32, 1143, 1, 4294967295, 4294967295, 1, 22, 8, 1144, 1, 4294967295, 4294967295, 5, 22, 8, 1145, 1, 684, 4294967295, 8, 22, 8, 1146, 1, 4294967295, 4294967295, 10, 22, 8, 1147, 2, 4294967295, 4294967295, 12, 22, 8, 1149, 1, 4294967295, 687, 9, 22, 8, 1150, 1, 4294967295, 4294967295, 1, 22, 32, 1151, 1, 4294967295, 4294967295, 1, 22, 8, 1152, 1, 4294967295, 4294967295, 1, 23, 8, 1153, 1, 4294967295, 4294967295, 3, 23, 8, 1154, 2, 692, 4294967295, 8, 23, 8, 1156, 1, 4294967295, 4294967295, 1, 23, 32, 1157, 1, 4294967295, 4294967295, 3, 23, 8, 1158, 2, 695, 4294967295, 8, 23, 8, 1160, 1, 4294967295, 4294967295, 1, 23, 8, 1161, 1, 4294967295, 4294967295, 1, 23, 8, 1162, 1, 4294967295, 4294967295, 1, 24, 32, 1163, 1, 4294967295, 4294967295, 1, 24, 8, 1164, 1, 4294967295, 4294967295, 1, 24, 8, 1165, 1, 4294967295, 4294967295, 1, 25, 8, 1166, 1, 4294967295, 4294967295, 5, 25, 8, 1167, 1, 703, 4294967295, 8, 25, 8, 1168, 1, 4294967295, 4294967295, 10, 25, 8, 1169, 2, 4294967295, 4294967295, 12, 25, 8, 1171, 1, 4294967295, 706, 9, 25, 8, 1172, 1, 4294967295, 4294967295, 1, 25, 8, 1173, 1, 4294967295, 4294967295, 5, 25, 8, 1174, 1, 709, 4294967295, 8, 25, 8, 1175, 1, 4294967295, 4294967295, 10, 25, 8, 1176, 2, 4294967295, 4294967295, 12, 25, 8, 1178, 1, 4294967295, 712, 9, 25, 8, 1179, 1, 4294967295, 4294967295, 1, 25, 8, 1180, 1, 4294967295, 4294967295, 1, 25, 32, 1181, 1, 4294967295, 4294967295, 1, 25, 8, 1182, 1, 4294967295, 4294967295, 1, 26, 8, 1183, 1, 4294967295, 4294967295, 1, 26, 8, 1184, 1, 4294967295, 4294967295, 1, 26, 8, 1185, 1, 4294967295, 4294967295, 1, 26, 8, 1186, 1, 4294967295, 4294967295, 1, 26, 8, 1187, 1, 4294967295, 4294967295, 3, 26, 8, 1188, 5, 722, 4294967295, 8, 26, 8, 1193, 1, 4294967295, 4294967295, 1, 27, 8, 1194, 1, 4294967295, 4294967295, 5, 27, 8, 1195, 1, 725, 4294967295, 8, 27, 8, 1196, 1, 4294967295, 4294967295, 10, 27, 8, 1197, 2, 4294967295, 4294967295, 12, 27, 8, 1199, 1, 4294967295, 728, 9, 27, 8, 1200, 1, 4294967295, 4294967295, 1, 27, 8, 1201, 1, 4294967295, 4294967295, 5, 27, 8, 1202, 1, 731, 4294967295, 8, 27, 8, 1203, 1, 4294967295, 4294967295, 10, 27, 8, 1204, 2, 4294967295, 4294967295, 12, 27, 8, 1206, 1, 4294967295, 734, 9, 27, 8, 1207, 1, 4294967295, 4294967295, 1, 27, 8, 1208, 1, 4294967295, 4294967295, 1, 27, 8, 1209, 1, 4294967295, 4294967295, 1, 27, 8, 1210, 1, 4294967295, 4294967295, 3, 27, 8, 1211, 2, 739, 4294967295, 8, 27, 8, 1213, 1, 4294967295, 4294967295, 1, 27, 8, 1214, 1, 4294967295, 4294967295, 1, 27, 8, 1215, 1, 4294967295, 4294967295, 1, 27, 32, 1216, 1, 4294967295, 4294967295, 1, 27, 8, 1217, 1, 4294967295, 4294967295, 1, 27, 32, 1218, 1, 4294967295, 4294967295, 3, 27, 8, 1219, 3, 746, 4294967295, 8, 27, 8, 1222, 1, 4294967295, 4294967295, 1, 28, 32, 1223, 1, 4294967295, 4294967295, 1, 28, 8, 1224, 1, 4294967295, 4294967295, 1, 28, 32, 1225, 1, 4294967295, 4294967295, 1, 28, 8, 1226, 1, 4294967295, 4294967295, 5, 28, 8, 1227, 1, 752, 4294967295, 8, 28, 8, 1228, 1, 4294967295, 4294967295, 10, 28, 8, 1229, 2, 4294967295, 4294967295, 12, 28, 8, 1231, 1, 4294967295, 755, 9, 28, 8, 1232, 1, 4294967295, 4294967295, 3, 28, 8, 1233, 2, 757, 4294967295, 8, 28, 8, 1235, 1, 4294967295, 4294967295, 1, 28, 32, 1236, 1, 4294967295, 4294967295, 1, 28, 8, 1237, 1, 4294967295, 4294967295, 1, 29, 8, 1238, 1, 4294967295, 4294967295, 5, 29, 8, 1239, 1, 762, 4294967295, 8, 29, 8, 1240, 1, 4294967295, 4294967295, 10, 29, 8, 1241, 2, 4294967295, 4294967295, 12, 29, 8, 1243, 1, 4294967295, 765, 9, 29, 8, 1244, 1, 4294967295, 4294967295, 1, 29, 8, 1245, 1, 4294967295, 4294967295, 1, 29, 32, 1246, 1, 4294967295, 4294967295, 1, 29, 32, 1247, 1, 4294967295, 4294967295, 1, 29, 32, 1248, 1, 4294967295, 4294967295, 1, 29, 32, 1249, 1, 4294967295, 4294967295, 5, 29, 8, 1250, 5, 772, 4294967295, 8, 29, 8, 1255, 1, 4294967295, 4294967295, 10, 29, 8, 1256, 2, 4294967295, 4294967295, 12, 29, 8, 1258, 1, 4294967295, 775, 9, 29, 8, 1259, 1, 4294967295, 4294967295, 1, 29, 8, 1260, 1, 4294967295, 4294967295, 3, 29, 8, 1261, 2, 778, 4294967295, 8, 29, 8, 1263, 1, 4294967295, 4294967295, 1, 29, 8, 1264, 1, 4294967295, 4294967295, 1, 29, 32, 1265, 1, 4294967295, 4294967295, 3, 29, 8, 1266, 3, 782, 4294967295, 8, 29, 8, 1269, 1, 4294967295, 4294967295, 1, 29, 8, 1270, 1, 4294967295, 4294967295, 3, 29, 8, 1271, 2, 785, 4294967295, 8, 29, 8, 1273, 1, 4294967295, 4294967295, 1, 30, 32, 1274, 1, 4294967295, 4294967295, 1, 30, 32, 1275, 1, 4294967295, 4294967295, 1, 30, 8, 1276, 1, 4294967295, 4294967295, 1, 30, 8, 1277, 1, 4294967295, 4294967295, 1, 31, 32, 1278, 1, 4294967295, 4294967295, 1, 31, 8, 1279, 1, 4294967295, 4294967295, 1, 31, 32, 1280, 1, 4294967295, 4294967295, 1, 31, 8, 1281, 1, 4294967295, 4294967295, 5, 31, 8, 1282, 1, 795, 4294967295, 8, 31, 8, 1283, 1, 4294967295, 4294967295, 10, 31, 8, 1284, 2, 4294967295, 4294967295, 12, 31, 8, 1286, 1, 4294967295, 798, 9, 31, 8, 1287, 1, 4294967295, 4294967295, 3, 31, 8, 1288, 2, 800, 4294967295, 8, 31, 8, 1290, 1, 4294967295, 4294967295, 1, 31, 32, 1291, 1, 4294967295, 4294967295, 1, 31, 8, 1292, 1, 4294967295, 4294967295, 1, 32, 8, 1293, 1, 4294967295, 4294967295, 5, 32, 8, 1294, 1, 805, 4294967295, 8, 32, 8, 1295, 1, 4294967295, 4294967295, 10, 32, 8, 1296, 2, 4294967295, 4294967295, 12, 32, 8, 1298, 1, 4294967295, 808, 9, 32, 8, 1299, 1, 4294967295, 4294967295, 1, 32, 32, 1300, 1, 4294967295, 4294967295, 1, 32, 8, 1301, 1, 4294967295, 4294967295, 5, 32, 8, 1302, 1, 812, 4294967295, 8, 32, 8, 1303, 1, 4294967295, 4294967295, 10, 32, 8, 1304, 2, 4294967295, 4294967295, 12, 32, 8, 1306, 1, 4294967295, 815, 9, 32, 8, 1307, 1, 4294967295, 4294967295, 1, 32, 32, 1308, 1, 4294967295, 4294967295, 1, 32, 8, 1309, 1, 4294967295, 4294967295, 1, 33, 32, 1310, 1, 4294967295, 4294967295, 1, 33, 8, 1311, 1, 4294967295, 4294967295, 1, 33, 8, 1312, 1, 4294967295, 4294967295, 1, 34, 8, 1313, 1, 4294967295, 4294967295, 5, 34, 8, 1314, 1, 823, 4294967295, 8, 34, 8, 1315, 1, 4294967295, 4294967295, 10, 34, 8, 1316, 2, 4294967295, 4294967295, 12, 34, 8, 1318, 1, 4294967295, 826, 9, 34, 8, 1319, 1, 4294967295, 4294967295, 1, 34, 8, 1320, 1, 4294967295, 4294967295, 5, 34, 8, 1321, 1, 829, 4294967295, 8, 34, 8, 1322, 1, 4294967295, 4294967295, 10, 34, 8, 1323, 2, 4294967295, 4294967295, 12, 34, 8, 1325, 1, 4294967295, 832, 9, 34, 8, 1326, 1, 4294967295, 4294967295, 1, 34, 32, 1327, 1, 4294967295, 4294967295, 1, 34, 8, 1328, 1, 4294967295, 4294967295, 3, 34, 8, 1329, 2, 836, 4294967295, 8, 34, 8, 1331, 1, 4294967295, 4294967295, 1, 34, 32, 1332, 1, 4294967295, 4294967295, 1, 34, 32, 1333, 1, 4294967295, 4294967295, 3, 34, 8, 1334, 2, 840, 4294967295, 8, 34, 8, 1336, 1, 4294967295, 4294967295, 1, 34, 8, 1337, 1, 4294967295, 4294967295, 1, 34, 8, 1338, 1, 4294967295, 4294967295, 1, 34, 8, 1339, 1, 4294967295, 4294967295, 1, 34, 8, 1340, 1, 4294967295, 4294967295, 1, 34, 32, 1341, 1, 4294967295, 4294967295, 1, 34, 8, 1342, 1, 4294967295, 4294967295, 1, 34, 32, 1343, 1, 4294967295, 4294967295, 3, 34, 8, 1344, 3, 849, 4294967295, 8, 34, 8, 1347, 1, 4294967295, 4294967295, 1, 35, 8, 1348, 1, 4294967295, 4294967295, 1, 35, 32, 1349, 1, 4294967295, 4294967295, 1, 35, 8, 1350, 1, 4294967295, 4294967295, 1, 36, 8, 1351, 1, 4294967295, 4294967295, 5, 36, 8, 1352, 1, 855, 4294967295, 8, 36, 8, 1353, 1, 4294967295, 4294967295, 10, 36, 8, 1354, 2, 4294967295, 4294967295, 12, 36, 8, 1356, 1, 4294967295, 858, 9, 36, 8, 1357, 1, 4294967295, 4294967295, 1, 36, 8, 1358, 1, 4294967295, 4294967295, 5, 36, 8, 1359, 1, 861, 4294967295, 8, 36, 8, 1360, 1, 4294967295, 4294967295, 10, 36, 8, 1361, 2, 4294967295, 4294967295, 12, 36, 8, 1363, 1, 4294967295, 864, 9, 36, 8, 1364, 1, 4294967295, 4294967295, 1, 36, 32, 1365, 1, 4294967295, 4294967295, 1, 36, 8, 1366, 1, 4294967295, 4294967295, 1, 36, 8, 1367, 1, 4294967295, 4294967295, 1, 36, 8, 1368, 1, 4294967295, 4294967295, 1, 36, 8, 1369, 1, 4294967295, 4294967295, 1, 36, 32, 1370, 1, 4294967295, 4294967295, 1, 36, 8, 1371, 1, 4294967295, 4294967295, 1, 36, 32, 1372, 1, 4294967295, 4294967295, 3, 36, 8, 1373, 3, 874, 4294967295, 8, 36, 8, 1376, 1, 4294967295, 4294967295, 1, 37, 8, 1377, 1, 4294967295, 4294967295, 5, 37, 8, 1378, 1, 877, 4294967295, 8, 37, 8, 1379, 1, 4294967295, 4294967295, 10, 37, 8, 1380, 2, 4294967295, 4294967295, 12, 37, 8, 1382, 1, 4294967295, 880, 9, 37, 8, 1383, 1, 4294967295, 4294967295, 1, 37, 8, 1384, 1, 4294967295, 4294967295, 5, 37, 8, 1385, 1, 883, 4294967295, 8, 37, 8, 1386, 1, 4294967295, 4294967295, 10, 37, 8, 1387, 2, 4294967295, 4294967295, 12, 37, 8, 1389, 1, 4294967295, 886, 9, 37, 8, 1390, 1, 4294967295, 4294967295, 1, 37, 8, 1391, 1, 4294967295, 4294967295, 1, 37, 8, 1392, 1, 4294967295, 4294967295, 3, 37, 8, 1393, 2, 890, 4294967295, 8, 37, 8, 1395, 1, 4294967295, 4294967295, 1, 37, 8, 1396, 1, 4294967295, 4294967295, 1, 37, 8, 1397, 1, 4294967295, 4294967295, 3, 37, 8, 1398, 2, 894, 4294967295, 8, 37, 8, 1400, 1, 4294967295, 4294967295, 1, 37, 8, 1401, 1, 4294967295, 4294967295, 1, 37, 8, 1402, 1, 4294967295, 4294967295, 5, 37, 8, 1403, 1, 898, 4294967295, 8, 37, 8, 1404, 1, 4294967295, 4294967295, 10, 37, 8, 1405, 2, 4294967295, 4294967295, 12, 37, 8, 1407, 1, 4294967295, 901, 9, 37, 8, 1408, 1, 4294967295, 4294967295, 1, 37, 8, 1409, 1, 4294967295, 4294967295, 1, 37, 8, 1410, 1, 4294967295, 4294967295, 1, 37, 32, 1411, 1, 4294967295, 4294967295, 1, 37, 8, 1412, 1, 4294967295, 4294967295, 1, 37, 32, 1413, 1, 4294967295, 4294967295, 3, 37, 8, 1414, 3, 908, 4294967295, 8, 37, 8, 1417, 1, 4294967295, 4294967295, 1, 38, 32, 1418, 1, 4294967295, 4294967295, 1, 38, 8, 1419, 1, 4294967295, 4294967295, 1, 38, 32, 1420, 1, 4294967295, 4294967295, 1, 38, 8, 1421, 1, 4294967295, 4294967295, 5, 38, 8, 1422, 1, 914, 4294967295, 8, 38, 8, 1423, 1, 4294967295, 4294967295, 10, 38, 8, 1424, 2, 4294967295, 4294967295, 12, 38, 8, 1426, 1, 4294967295, 917, 9, 38, 8, 1427, 1, 4294967295, 4294967295, 1, 38, 32, 1428, 1, 4294967295, 4294967295, 1, 38, 8, 1429, 1, 4294967295, 4294967295, 1, 39, 8, 1430, 1, 4294967295, 4294967295, 5, 39, 8, 1431, 1, 922, 4294967295, 8, 39, 8, 1432, 1, 4294967295, 4294967295, 10, 39, 8, 1433, 2, 4294967295, 4294967295, 12, 39, 8, 1435, 1, 4294967295, 925, 9, 39, 8, 1436, 1, 4294967295, 4294967295, 1, 39, 32, 1437, 1, 4294967295, 4294967295, 3, 39, 8, 1438, 2, 928, 4294967295, 8, 39, 8, 1440, 1, 4294967295, 4294967295, 1, 39, 8, 1441, 1, 4294967295, 4294967295, 1, 39, 8, 1442, 1, 4294967295, 4294967295, 1, 40, 32, 1443, 1, 4294967295, 4294967295, 1, 40, 8, 1444, 1, 4294967295, 4294967295, 1, 40, 32, 1445, 1, 4294967295, 4294967295, 1, 40, 8, 1446, 1, 4294967295, 4294967295, 1, 40, 32, 1447, 1, 4294967295, 4294967295, 1, 40, 8, 1448, 1, 4294967295, 4294967295, 5, 40, 8, 1449, 1, 938, 4294967295, 8, 40, 8, 1450, 1, 4294967295, 4294967295, 10, 40, 8, 1451, 2, 4294967295, 4294967295, 12, 40, 8, 1453, 1, 4294967295, 941, 9, 40, 8, 1454, 1, 4294967295, 4294967295, 1, 41, 8, 1455, 1, 4294967295, 4294967295, 1, 41, 8, 1456, 1, 4294967295, 4294967295, 1, 41, 8, 1457, 1, 4294967295, 4294967295, 1, 41, 8, 1458, 1, 4294967295, 4294967295, 1, 41, 8, 1459, 1, 4294967295, 4294967295, 3, 41, 8, 1460, 5, 948, 4294967295, 8, 41, 8, 1465, 1, 4294967295, 4294967295, 1, 42, 32, 1466, 1, 4294967295, 4294967295, 1, 42, 8, 1467, 1, 4294967295, 4294967295, 1, 42, 32, 1468, 1, 4294967295, 4294967295, 1, 42, 8, 1469, 1, 4294967295, 4294967295, 5, 42, 8, 1470, 1, 954, 4294967295, 8, 42, 8, 1471, 1, 4294967295, 4294967295, 10, 42, 8, 1472, 2, 4294967295, 4294967295, 12, 42, 8, 1474, 1, 4294967295, 957, 9, 42, 8, 1475, 1, 4294967295, 4294967295, 1, 43, 8, 1476, 1, 4294967295, 4294967295, 1, 43, 8, 1477, 1, 4294967295, 4294967295, 1, 44, 32, 1478, 1, 4294967295, 4294967295, 1, 44, 32, 1479, 1, 4294967295, 4294967295, 1, 44, 8, 1480, 1, 4294967295, 4294967295, 1, 45, 32, 1481, 1, 4294967295, 4294967295, 1, 45, 32, 1482, 1, 4294967295, 4294967295, 3, 45, 8, 1483, 2, 966, 4294967295, 8, 45, 8, 1485, 1, 4294967295, 4294967295, 1, 45, 32, 1486, 1, 4294967295, 4294967295, 1, 45, 32, 1487, 1, 4294967295, 4294967295, 3, 45, 8, 1488, 2, 970, 4294967295, 8, 45, 8, 1490, 1, 4294967295, 4294967295, 3, 45, 8, 1491, 2, 972, 4294967295, 8, 45, 8, 1493, 1, 4294967295, 4294967295, 1, 46, 32, 1494, 1, 4294967295, 4294967295, 1, 46, 32, 1495, 1, 4294967295, 4294967295, 1, 46, 32, 1496, 1, 4294967295, 4294967295, 1, 46, 8, 1497, 1, 4294967295, 4294967295, 1, 47, 32, 1498, 1, 4294967295, 4294967295, 1, 47, 8, 1499, 1, 4294967295, 4294967295, 1, 48, 8, 1500, 1, 4294967295, 4294967295, 1, 48, 8, 1501, 1, 4294967295, 4294967295, 1, 49, 8, 1502, 1, 4294967295, 4294967295, 5, 49, 8, 1503, 1, 983, 4294967295, 8, 49, 8, 1504, 1, 4294967295, 4294967295, 10, 49, 8, 1505, 2, 4294967295, 4294967295, 12, 49, 8, 1507, 1, 4294967295, 986, 9, 49, 8, 1508, 1, 4294967295, 4294967295, 1, 49, 8, 1509, 1, 4294967295, 4294967295, 5, 49, 8, 1510, 1, 989, 4294967295, 8, 49, 8, 1511, 1, 4294967295, 4294967295, 10, 49, 8, 1512, 2, 4294967295, 4294967295, 12, 49, 8, 1514, 1, 4294967295, 992, 9, 49, 8, 1515, 1, 4294967295, 4294967295, 1, 49, 8, 1516, 1, 4294967295, 4294967295, 1, 49, 8, 1517, 1, 4294967295, 4294967295, 3, 49, 8, 1518, 2, 996, 4294967295, 8, 49, 8, 1520, 1, 4294967295, 4294967295, 1, 49, 32, 1521, 1, 4294967295, 4294967295, 1, 49, 32, 1522, 1, 4294967295, 4294967295, 3, 49, 8, 1523, 2, 1000, 4294967295, 8, 49, 8, 1525, 1, 4294967295, 4294967295, 1, 49, 32, 1526, 1, 4294967295, 4294967295, 1, 49, 32, 1527, 1, 4294967295, 4294967295, 1, 49, 32, 1528, 1, 4294967295, 4294967295, 1, 49, 32, 1529, 1, 4294967295, 4294967295, 1, 49, 32, 1530, 1, 4294967295, 4294967295, 1, 49, 32, 1531, 1, 4294967295, 4294967295, 1, 49, 32, 1532, 1, 4294967295, 4294967295, 1, 49, 32, 1533, 1, 4294967295, 4294967295, 1, 49, 32, 1534, 1, 4294967295, 4294967295, 1, 49, 32, 1535, 1, 4294967295, 4294967295, 1, 49, 8, 1536, 1, 4294967295, 4294967295, 1, 49, 8, 1537, 1, 4294967295, 4294967295, 1, 49, 32, 1538, 1, 4294967295, 4294967295, 1, 49, 32, 1539, 1, 4294967295, 4294967295, 1, 49, 32, 1540, 1, 4294967295, 4294967295, 1, 49, 32, 1541, 1, 4294967295, 4294967295, 1, 49, 32, 1542, 1, 4294967295, 4294967295, 1, 49, 32, 1543, 1, 4294967295, 4294967295, 1, 49, 32, 1544, 1, 4294967295, 4294967295, 1, 49, 32, 1545, 1, 4294967295, 4294967295, 1, 49, 32, 1546, 1, 4294967295, 4294967295, 1, 49, 32, 1547, 1, 4294967295, 4294967295, 1, 49, 32, 1548, 1, 4294967295, 4294967295, 1, 49, 32, 1549, 1, 4294967295, 4294967295, 1, 49, 32, 1550, 1, 4294967295, 4294967295, 1, 49, 32, 1551, 1, 4294967295, 4294967295, 1, 49, 32, 1552, 1, 4294967295, 4294967295, 1, 49, 32, 1553, 1, 4294967295, 4294967295, 1, 49, 32, 1554, 1, 4294967295, 4294967295, 1, 49, 32, 1555, 1, 4294967295, 4294967295, 1, 49, 32, 1556, 1, 4294967295, 4294967295, 1, 49, 32, 1557, 1, 4294967295, 4294967295, 1, 49, 32, 1558, 1, 4294967295, 4294967295, 1, 49, 8, 1559, 1, 4294967295, 4294967295, 1, 49, 8, 1560, 1, 4294967295, 4294967295, 3, 49, 8, 1561, 35, 1037, 4294967295, 8, 49, 8, 1596, 1, 4294967295, 4294967295, 1, 49, 8, 1597, 1, 4294967295, 4294967295, 1, 49, 8, 1598, 1, 4294967295, 4294967295, 1, 49, 8, 1599, 1, 4294967295, 4294967295, 1, 49, 32, 1600, 1, 4294967295, 4294967295, 1, 49, 8, 1601, 1, 4294967295, 4294967295, 1, 49, 32, 1602, 1, 4294967295, 4294967295, 3, 49, 8, 1603, 3, 1045, 4294967295, 8, 49, 8, 1606, 1, 4294967295, 4294967295, 1, 50, 8, 1607, 1, 4294967295, 4294967295, 1, 50, 8, 1608, 1, 4294967295, 4294967295, 3, 50, 8, 1609, 2, 1049, 4294967295, 8, 50, 8, 1611, 1, 4294967295, 4294967295, 1, 51, 8, 1612, 1, 4294967295, 4294967295, 5, 51, 8, 1613, 1, 1052, 4294967295, 8, 51, 8, 1614, 1, 4294967295, 4294967295, 10, 51, 8, 1615, 2, 4294967295, 4294967295, 12, 51, 8, 1617, 1, 4294967295, 1055, 9, 51, 8, 1618, 1, 4294967295, 4294967295, 1, 51, 8, 1619, 1, 4294967295, 4294967295, 5, 51, 8, 1620, 1, 1058, 4294967295, 8, 51, 8, 1621, 1, 4294967295, 4294967295, 10, 51, 8, 1622, 2, 4294967295, 4294967295, 12, 51, 8, 1624, 1, 4294967295, 1061, 9, 51, 8, 1625, 1, 4294967295, 4294967295, 1, 51, 32, 1626, 1, 4294967295, 4294967295, 1, 51, 8, 1627, 1, 4294967295, 4294967295, 1, 51, 32, 1628, 1, 4294967295, 4294967295, 1, 51, 8, 1629, 1, 4294967295, 4294967295, 5, 51, 8, 1630, 1, 1067, 4294967295, 8, 51, 8, 1631, 1, 4294967295, 4294967295, 10, 51, 8, 1632, 2, 4294967295, 4294967295, 12, 51, 8, 1634, 1, 4294967295, 1070, 9, 51, 8, 1635, 1, 4294967295, 4294967295, 1, 51, 8, 1636, 1, 4294967295, 4294967295, 5, 51, 8, 1637, 1, 1073, 4294967295, 8, 51, 8, 1638, 1, 4294967295, 4294967295, 10, 51, 8, 1639, 2, 4294967295, 4294967295, 12, 51, 8, 1641, 1, 4294967295, 1076, 9, 51, 8, 1642, 1, 4294967295, 4294967295, 1, 51, 8, 1643, 1, 4294967295, 4294967295, 5, 51, 8, 1644, 1, 1079, 4294967295, 8, 51, 8, 1645, 1, 4294967295, 4294967295, 10, 51, 8, 1646, 2, 4294967295, 4294967295, 12, 51, 8, 1648, 1, 4294967295, 1082, 9, 51, 8, 1649, 1, 4294967295, 4294967295, 1, 52, 8, 1650, 1, 4294967295, 4294967295, 5, 52, 8, 1651, 1, 1085, 4294967295, 8, 52, 8, 1652, 1, 4294967295, 4294967295, 10, 52, 8, 1653, 2, 4294967295, 4294967295, 12, 52, 8, 1655, 1, 4294967295, 1088, 9, 52, 8, 1656, 1, 4294967295, 4294967295, 1, 52, 8, 1657, 1, 4294967295, 4294967295, 5, 52, 8, 1658, 1, 1091, 4294967295, 8, 52, 8, 1659, 1, 4294967295, 4294967295, 10, 52, 8, 1660, 2, 4294967295, 4294967295, 12, 52, 8, 1662, 1, 4294967295, 1094, 9, 52, 8, 1663, 1, 4294967295, 4294967295, 1, 52, 32, 1664, 1, 4294967295, 4294967295, 1, 52, 8, 1665, 1, 4294967295, 4294967295, 1, 52, 32, 1666, 1, 4294967295, 4294967295, 1, 52, 8, 1667, 1, 4294967295, 4294967295, 5, 52, 8, 1668, 1, 1100, 4294967295, 8, 52, 8, 1669, 1, 4294967295, 4294967295, 10, 52, 8, 1670, 2, 4294967295, 4294967295, 12, 52, 8, 1672, 1, 4294967295, 1103, 9, 52, 8, 1673, 1, 4294967295, 4294967295, 1, 52, 8, 1674, 1, 4294967295, 4294967295, 5, 52, 8, 1675, 1, 1106, 4294967295, 8, 52, 8, 1676, 1, 4294967295, 4294967295, 10, 52, 8, 1677, 2, 4294967295, 4294967295, 12, 52, 8, 1679, 1, 4294967295, 1109, 9, 52, 8, 1680, 1, 4294967295, 4294967295, 1, 52, 8, 1681, 1, 4294967295, 4294967295, 5, 52, 8, 1682, 1, 1112, 4294967295, 8, 52, 8, 1683, 1, 4294967295, 4294967295, 10, 52, 8, 1684, 2, 4294967295, 4294967295, 12, 52, 8, 1686, 1, 4294967295, 1115, 9, 52, 8, 1687, 1, 4294967295, 4294967295, 1, 52, 32, 1688, 1, 4294967295, 4294967295, 1, 52, 32, 1689, 1, 4294967295, 4294967295, 3, 52, 8, 1690, 2, 1119, 4294967295, 8, 52, 8, 1692, 1, 4294967295, 4294967295, 1, 53, 8, 1693, 1, 4294967295, 4294967295, 1, 53, 8, 1694, 1, 4294967295, 4294967295, 1, 53, 8, 1695, 1, 4294967295, 4294967295, 3, 53, 8, 1696, 3, 1124, 4294967295, 8, 53, 8, 1699, 1, 4294967295, 4294967295, 1, 54, 8, 1700, 1, 4294967295, 4294967295, 5, 54, 8, 1701, 1, 1127, 4294967295, 8, 54, 8, 1702, 1, 4294967295, 4294967295, 10, 54, 8, 1703, 2, 4294967295, 4294967295, 12, 54, 8, 1705, 1, 4294967295, 1130, 9, 54, 8, 1706, 1, 4294967295, 4294967295, 1, 54, 8, 1707, 1, 4294967295, 4294967295, 5, 54, 8, 1708, 1, 1133, 4294967295, 8, 54, 8, 1709, 1, 4294967295, 4294967295, 10, 54, 8, 1710, 2, 4294967295, 4294967295, 12, 54, 8, 1712, 1, 4294967295, 1136, 9, 54, 8, 1713, 1, 4294967295, 4294967295, 1, 54, 32, 1714, 1, 4294967295, 4294967295, 1, 54, 8, 1715, 1, 4294967295, 4294967295, 1, 54, 8, 1716, 1, 4294967295, 4294967295, 3, 54, 8, 1717, 2, 1141, 4294967295, 8, 54, 8, 1719, 1, 4294967295, 4294967295, 1, 54, 8, 1720, 1, 4294967295, 4294967295, 1, 54, 8, 1721, 1, 4294967295, 4294967295, 1, 54, 32, 1722, 1, 4294967295, 4294967295, 3, 54, 8, 1723, 2, 1146, 4294967295, 8, 54, 8, 1725, 1, 4294967295, 4294967295, 1, 55, 32, 1726, 1, 4294967295, 4294967295, 1, 55, 8, 1727, 1, 4294967295, 4294967295, 5, 55, 8, 1728, 1, 1150, 4294967295, 8, 55, 8, 1729, 1, 4294967295, 4294967295, 10, 55, 8, 1730, 2, 4294967295, 4294967295, 12, 55, 8, 1732, 1, 4294967295, 1153, 9, 55, 8, 1733, 1, 4294967295, 4294967295, 1, 55, 32, 1734, 1, 4294967295, 4294967295, 1, 55, 8, 1735, 1, 4294967295, 4294967295, 1, 56, 8, 1736, 1, 4294967295, 4294967295, 5, 56, 8, 1737, 1, 1158, 4294967295, 8, 56, 8, 1738, 1, 4294967295, 4294967295, 10, 56, 8, 1739, 2, 4294967295, 4294967295, 12, 56, 8, 1741, 1, 4294967295, 1161, 9, 56, 8, 1742, 1, 4294967295, 4294967295, 1, 56, 8, 1743, 1, 4294967295, 4294967295, 5, 56, 8, 1744, 1, 1164, 4294967295, 8, 56, 8, 1745, 1, 4294967295, 4294967295, 10, 56, 8, 1746, 2, 4294967295, 4294967295, 12, 56, 8, 1748, 1, 4294967295, 1167, 9, 56, 8, 1749, 1, 4294967295, 4294967295, 1, 56, 32, 1750, 1, 4294967295, 4294967295, 1, 56, 8, 1751, 1, 4294967295, 4294967295, 1, 56, 8, 1752, 1, 4294967295, 4294967295, 1, 56, 32, 1753, 1, 4294967295, 4294967295, 1, 56, 8, 1754, 1, 4294967295, 4294967295, 1, 56, 32, 1755, 1, 4294967295, 4294967295, 3, 56, 8, 1756, 3, 1175, 4294967295, 8, 56, 8, 1759, 1, 4294967295, 4294967295, 1, 57, 8, 1760, 1, 4294967295, 4294967295, 5, 57, 8, 1761, 1, 1178, 4294967295, 8, 57, 8, 1762, 1, 4294967295, 4294967295, 10, 57, 8, 1763, 2, 4294967295, 4294967295, 12, 57, 8, 1765, 1, 4294967295, 1181, 9, 57, 8, 1766, 1, 4294967295, 4294967295, 1, 57, 8, 1767, 1, 4294967295, 4294967295, 5, 57, 8, 1768, 1, 1184, 4294967295, 8, 57, 8, 1769, 1, 4294967295, 4294967295, 10, 57, 8, 1770, 2, 4294967295, 4294967295, 12, 57, 8, 1772, 1, 4294967295, 1187, 9, 57, 8, 1773, 1, 4294967295, 4294967295, 1, 57, 8, 1774, 1, 4294967295, 4294967295, 1, 57, 8, 1775, 1, 4294967295, 4294967295, 3, 57, 8, 1776, 2, 1191, 4294967295, 8, 57, 8, 1778, 1, 4294967295, 4294967295, 1, 57, 32, 1779, 1, 4294967295, 4294967295, 1, 57, 8, 1780, 1, 4294967295, 4294967295, 1, 57, 8, 1781, 1, 4294967295, 4294967295, 1, 57, 8, 1782, 1, 4294967295, 4294967295, 1, 57, 32, 1783, 1, 4294967295, 4294967295, 1, 57, 8, 1784, 1, 4294967295, 4294967295, 3, 57, 8, 1785, 2, 1199, 4294967295, 8, 57, 8, 1787, 1, 4294967295, 4294967295, 1, 58, 32, 1788, 1, 4294967295, 4294967295, 1, 58, 8, 1789, 1, 4294967295, 4294967295, 1, 58, 32, 1790, 1, 4294967295, 4294967295, 1, 58, 8, 1791, 1, 4294967295, 4294967295, 5, 58, 8, 1792, 1, 1205, 4294967295, 8, 58, 8, 1793, 1, 4294967295, 4294967295, 10, 58, 8, 1794, 2, 4294967295, 4294967295, 12, 58, 8, 1796, 1, 4294967295, 1208, 9, 58, 8, 1797, 1, 4294967295, 4294967295, 1, 58, 32, 1798, 1, 4294967295, 4294967295, 1, 58, 8, 1799, 1, 4294967295, 4294967295, 1, 59, 8, 1800, 1, 4294967295, 4294967295, 5, 59, 8, 1801, 1, 1213, 4294967295, 8, 59, 8, 1802, 1, 4294967295, 4294967295, 10, 59, 8, 1803, 2, 4294967295, 4294967295, 12, 59, 8, 1805, 1, 4294967295, 1216, 9, 59, 8, 1806, 1, 4294967295, 4294967295, 1, 59, 8, 1807, 1, 4294967295, 4294967295, 5, 59, 8, 1808, 1, 1219, 4294967295, 8, 59, 8, 1809, 1, 4294967295, 4294967295, 10, 59, 8, 1810, 2, 4294967295, 4294967295, 12, 59, 8, 1812, 1, 4294967295, 1222, 9, 59, 8, 1813, 1, 4294967295, 4294967295, 1, 59, 8, 1814, 1, 4294967295, 4294967295, 1, 59, 8, 1815, 1, 4294967295, 4294967295, 3, 59, 8, 1816, 2, 1226, 4294967295, 8, 59, 8, 1818, 1, 4294967295, 4294967295, 1, 59, 8, 1819, 1, 4294967295, 4294967295, 1, 59, 8, 1820, 1, 4294967295, 4294967295, 1, 59, 8, 1821, 1, 4294967295, 4294967295, 1, 59, 32, 1822, 1, 4294967295, 4294967295, 1, 59, 8, 1823, 1, 4294967295, 4294967295, 3, 59, 8, 1824, 2, 1233, 4294967295, 8, 59, 8, 1826, 1, 4294967295, 4294967295, 1, 59, 8, 1827, 1, 4294967295, 4294967295, 1, 59, 8, 1828, 1, 4294967295, 4294967295, 3, 59, 8, 1829, 2, 1237, 4294967295, 8, 59, 8, 1831, 1, 4294967295, 4294967295, 1, 59, 32, 1832, 1, 4294967295, 4294967295, 1, 59, 8, 1833, 1, 4294967295, 4294967295, 3, 59, 8, 1834, 2, 1241, 4294967295, 8, 59, 8, 1836, 1, 4294967295, 4294967295, 1, 60, 8, 1837, 1, 4294967295, 4294967295, 1, 60, 8, 1838, 1, 4294967295, 4294967295, 3, 60, 8, 1839, 2, 1245, 4294967295, 8, 60, 8, 1841, 1, 4294967295, 4294967295, 1, 61, 8, 1842, 1, 4294967295, 4294967295, 5, 61, 8, 1843, 1, 1248, 4294967295, 8, 61, 8, 1844, 1, 4294967295, 4294967295, 10, 61, 8, 1845, 2, 4294967295, 4294967295, 12, 61, 8, 1847, 1, 4294967295, 1251, 9, 61, 8, 1848, 1, 4294967295, 4294967295, 1, 61, 8, 1849, 1, 4294967295, 4294967295, 5, 61, 8, 1850, 1, 1254, 4294967295, 8, 61, 8, 1851, 1, 4294967295, 4294967295, 10, 61, 8, 1852, 2, 4294967295, 4294967295, 12, 61, 8, 1854, 1, 4294967295, 1257, 9, 61, 8, 1855, 1, 4294967295, 4294967295, 1, 61, 32, 1856, 1, 4294967295, 4294967295, 1, 61, 8, 1857, 1, 4294967295, 4294967295, 1, 61, 8, 1858, 1, 4294967295, 4294967295, 3, 61, 8, 1859, 2, 1262, 4294967295, 8, 61, 8, 1861, 1, 4294967295, 4294967295, 1, 61, 32, 1862, 1, 4294967295, 4294967295, 1, 61, 8, 1863, 1, 4294967295, 4294967295, 1, 61, 32, 1864, 1, 4294967295, 4294967295, 1, 61, 8, 1865, 1, 4294967295, 4294967295, 5, 61, 8, 1866, 1, 1268, 4294967295, 8, 61, 8, 1867, 1, 4294967295, 4294967295, 10, 61, 8, 1868, 2, 4294967295, 4294967295, 12, 61, 8, 1870, 1, 4294967295, 1271, 9, 61, 8, 1871, 1, 4294967295, 4294967295, 1, 61, 32, 1872, 1, 4294967295, 4294967295, 3, 61, 8, 1873, 2, 1274, 4294967295, 8, 61, 8, 1875, 1, 4294967295, 4294967295, 3, 61, 8, 1876, 2, 1276, 4294967295, 8, 61, 8, 1878, 1, 4294967295, 4294967295, 1, 61, 32, 1879, 1, 4294967295, 4294967295, 3, 61, 8, 1880, 2, 1279, 4294967295, 8, 61, 8, 1882, 1, 4294967295, 4294967295, 1, 61, 32, 1883, 1, 4294967295, 4294967295, 3, 61, 8, 1884, 2, 1282, 4294967295, 8, 61, 8, 1886, 1, 4294967295, 4294967295, 1, 62, 32, 1887, 1, 4294967295, 4294967295, 1, 62, 8, 1888, 1, 4294967295, 4294967295, 1, 62, 32, 1889, 1, 4294967295, 4294967295, 1, 62, 8, 1890, 1, 4294967295, 4294967295, 5, 62, 8, 1891, 1, 1288, 4294967295, 8, 62, 8, 1892, 1, 4294967295, 4294967295, 10, 62, 8, 1893, 2, 4294967295, 4294967295, 12, 62, 8, 1895, 1, 4294967295, 1291, 9, 62, 8, 1896, 1, 4294967295, 4294967295, 1, 63, 8, 1897, 1, 4294967295, 4294967295, 1, 63, 8, 1898, 1, 4294967295, 4294967295, 3, 63, 8, 1899, 2, 1295, 4294967295, 8, 63, 8, 1901, 1, 4294967295, 4294967295, 1, 64, 8, 1902, 1, 4294967295, 4294967295, 1, 64, 8, 1903, 1, 4294967295, 4294967295, 1, 64, 8, 1904, 1, 4294967295, 4294967295, 1, 65, 8, 1905, 1, 4294967295, 4294967295, 1, 65, 8, 1906, 1, 4294967295, 4294967295, 1, 66, 8, 1907, 1, 4294967295, 4294967295, 5, 66, 8, 1908, 1, 1303, 4294967295, 8, 66, 8, 1909, 1, 4294967295, 4294967295, 10, 66, 8, 1910, 2, 4294967295, 4294967295, 12, 66, 8, 1912, 1, 4294967295, 1306, 9, 66, 8, 1913, 1, 4294967295, 4294967295, 1, 66, 8, 1914, 1, 4294967295, 4294967295, 5, 66, 8, 1915, 1, 1309, 4294967295, 8, 66, 8, 1916, 1, 4294967295, 4294967295, 10, 66, 8, 1917, 2, 4294967295, 4294967295, 12, 66, 8, 1919, 1, 4294967295, 1312, 9, 66, 8, 1920, 1, 4294967295, 4294967295, 1, 66, 8, 1921, 1, 4294967295, 4294967295, 1, 66, 8, 1922, 1, 4294967295, 4294967295, 3, 66, 8, 1923, 2, 1316, 4294967295, 8, 66, 8, 1925, 1, 4294967295, 4294967295, 1, 67, 8, 1926, 1, 4294967295, 4294967295, 1, 67, 8, 1927, 1, 4294967295, 4294967295, 1, 67, 8, 1928, 1, 4294967295, 4294967295, 1, 67, 8, 1929, 1, 4294967295, 4294967295, 1, 67, 8, 1930, 1, 4294967295, 4294967295, 1, 67, 8, 1931, 1, 4294967295, 4294967295, 3, 67, 8, 1932, 6, 1324, 4294967295, 8, 67, 8, 1938, 1, 4294967295, 4294967295, 1, 68, 8, 1939, 1, 4294967295, 4294967295, 5, 68, 8, 1940, 1, 1327, 4294967295, 8, 68, 8, 1941, 1, 4294967295, 4294967295, 10, 68, 8, 1942, 2, 4294967295, 4294967295, 12, 68, 8, 1944, 1, 4294967295, 1330, 9, 68, 8, 1945, 1, 4294967295, 4294967295, 1, 68, 8, 1946, 1, 4294967295, 4294967295, 5, 68, 8, 1947, 1, 1333, 4294967295, 8, 68, 8, 1948, 1, 4294967295, 4294967295, 10, 68, 8, 1949, 2, 4294967295, 4294967295, 12, 68, 8, 1951, 1, 4294967295, 1336, 9, 68, 8, 1952, 1, 4294967295, 4294967295, 1, 68, 32, 1953, 1, 4294967295, 4294967295, 1, 68, 8, 1954, 1, 4294967295, 4294967295, 1, 68, 8, 1955, 1, 4294967295, 4294967295, 3, 68, 8, 1956, 2, 1341, 4294967295, 8, 68, 8, 1958, 1, 4294967295, 4294967295, 1, 68, 8, 1959, 1, 4294967295, 4294967295, 3, 68, 8, 1960, 2, 1344, 4294967295, 8, 68, 8, 1962, 1, 4294967295, 4294967295, 1, 68, 8, 1963, 1, 4294967295, 4294967295, 3, 68, 8, 1964, 2, 1347, 4294967295, 8, 68, 8, 1966, 1, 4294967295, 4294967295, 1, 68, 8, 1967, 1, 4294967295, 4294967295, 5, 68, 8, 1968, 1, 1350, 4294967295, 8, 68, 8, 1969, 1, 4294967295, 4294967295, 10, 68, 8, 1970, 2, 4294967295, 4294967295, 12, 68, 8, 1972, 1, 4294967295, 1353, 9, 68, 8, 1973, 1, 4294967295, 4294967295, 1, 68, 32, 1974, 1, 4294967295, 4294967295, 1, 68, 8, 1975, 1, 4294967295, 4294967295, 5, 68, 8, 1976, 1, 1357, 4294967295, 8, 68, 8, 1977, 1, 4294967295, 4294967295, 10, 68, 8, 1978, 2, 4294967295, 4294967295, 12, 68, 8, 1980, 1, 4294967295, 1360, 9, 68, 8, 1981, 1, 4294967295, 4294967295, 1, 68, 32, 1982, 1, 4294967295, 4294967295, 3, 68, 8, 1983, 2, 1363, 4294967295, 8, 68, 8, 1985, 1, 4294967295, 4294967295, 1, 68, 32, 1986, 1, 4294967295, 4294967295, 3, 68, 8, 1987, 2, 1366, 4294967295, 8, 68, 8, 1989, 1, 4294967295, 4294967295, 1, 69, 8, 1990, 1, 4294967295, 4294967295, 5, 69, 8, 1991, 1, 1369, 4294967295, 8, 69, 8, 1992, 1, 4294967295, 4294967295, 10, 69, 8, 1993, 2, 4294967295, 4294967295, 12, 69, 8, 1995, 1, 4294967295, 1372, 9, 69, 8, 1996, 1, 4294967295, 4294967295, 1, 69, 8, 1997, 1, 4294967295, 4294967295, 5, 69, 8, 1998, 1, 1375, 4294967295, 8, 69, 8, 1999, 1, 4294967295, 4294967295, 10, 69, 8, 2000, 2, 4294967295, 4294967295, 12, 69, 8, 2002, 1, 4294967295, 1378, 9, 69, 8, 2003, 1, 4294967295, 4294967295, 1, 69, 32, 2004, 1, 4294967295, 4294967295, 1, 69, 8, 2005, 1, 4294967295, 4294967295, 3, 69, 8, 2006, 2, 1382, 4294967295, 8, 69, 8, 2008, 1, 4294967295, 4294967295, 1, 69, 8, 2009, 1, 4294967295, 4294967295, 3, 69, 8, 2010, 2, 1385, 4294967295, 8, 69, 8, 2012, 1, 4294967295, 4294967295, 1, 69, 8, 2013, 1, 4294967295, 4294967295, 5, 69, 8, 2014, 1, 1388, 4294967295, 8, 69, 8, 2015, 1, 4294967295, 4294967295, 10, 69, 8, 2016, 2, 4294967295, 4294967295, 12, 69, 8, 2018, 1, 4294967295, 1391, 9, 69, 8, 2019, 1, 4294967295, 4294967295, 1, 69, 32, 2020, 1, 4294967295, 4294967295, 1, 69, 8, 2021, 1, 4294967295, 4294967295, 5, 69, 8, 2022, 1, 1395, 4294967295, 8, 69, 8, 2023, 1, 4294967295, 4294967295, 10, 69, 8, 2024, 2, 4294967295, 4294967295, 12, 69, 8, 2026, 1, 4294967295, 1398, 9, 69, 8, 2027, 1, 4294967295, 4294967295, 1, 69, 32, 2028, 1, 4294967295, 4294967295, 1, 69, 8, 2029, 1, 4294967295, 4294967295, 1, 70, 8, 2030, 1, 4294967295, 4294967295, 5, 70, 8, 2031, 1, 1403, 4294967295, 8, 70, 8, 2032, 1, 4294967295, 4294967295, 10, 70, 8, 2033, 2, 4294967295, 4294967295, 12, 70, 8, 2035, 1, 4294967295, 1406, 9, 70, 8, 2036, 1, 4294967295, 4294967295, 1, 70, 8, 2037, 1, 4294967295, 4294967295, 5, 70, 8, 2038, 1, 1409, 4294967295, 8, 70, 8, 2039, 1, 4294967295, 4294967295, 10, 70, 8, 2040, 2, 4294967295, 4294967295, 12, 70, 8, 2042, 1, 4294967295, 1412, 9, 70, 8, 2043, 1, 4294967295, 4294967295, 1, 70, 32, 2044, 1, 4294967295, 4294967295, 1, 70, 8, 2045, 1, 4294967295, 4294967295, 1, 70, 8, 2046, 1, 4294967295, 4294967295, 3, 70, 8, 2047, 2, 1417, 4294967295, 8, 70, 8, 2049, 1, 4294967295, 4294967295, 1, 70, 8, 2050, 1, 4294967295, 4294967295, 3, 70, 8, 2051, 2, 1420, 4294967295, 8, 70, 8, 2053, 1, 4294967295, 4294967295, 1, 70, 8, 2054, 1, 4294967295, 4294967295, 3, 70, 8, 2055, 2, 1423, 4294967295, 8, 70, 8, 2057, 1, 4294967295, 4294967295, 1, 70, 8, 2058, 1, 4294967295, 4294967295, 5, 70, 8, 2059, 1, 1426, 4294967295, 8, 70, 8, 2060, 1, 4294967295, 4294967295, 10, 70, 8, 2061, 2, 4294967295, 4294967295, 12, 70, 8, 2063, 1, 4294967295, 1429, 9, 70, 8, 2064, 1, 4294967295, 4294967295, 1, 70, 32, 2065, 1, 4294967295, 4294967295, 1, 70, 8, 2066, 1, 4294967295, 4294967295, 5, 70, 8, 2067, 1, 1433, 4294967295, 8, 70, 8, 2068, 1, 4294967295, 4294967295, 10, 70, 8, 2069, 2, 4294967295, 4294967295, 12, 70, 8, 2071, 1, 4294967295, 1436, 9, 70, 8, 2072, 1, 4294967295, 4294967295, 1, 70, 32, 2073, 1, 4294967295, 4294967295, 3, 70, 8, 2074, 2, 1439, 4294967295, 8, 70, 8, 2076, 1, 4294967295, 4294967295, 1, 70, 32, 2077, 1, 4294967295, 4294967295, 3, 70, 8, 2078, 2, 1442, 4294967295, 8, 70, 8, 2080, 1, 4294967295, 4294967295, 1, 71, 8, 2081, 1, 4294967295, 4294967295, 5, 71, 8, 2082, 1, 1445, 4294967295, 8, 71, 8, 2083, 1, 4294967295, 4294967295, 10, 71, 8, 2084, 2, 4294967295, 4294967295, 12, 71, 8, 2086, 1, 4294967295, 1448, 9, 71, 8, 2087, 1, 4294967295, 4294967295, 1, 71, 8, 2088, 1, 4294967295, 4294967295, 5, 71, 8, 2089, 1, 1451, 4294967295, 8, 71, 8, 2090, 1, 4294967295, 4294967295, 10, 71, 8, 2091, 2, 4294967295, 4294967295, 12, 71, 8, 2093, 1, 4294967295, 1454, 9, 71, 8, 2094, 1, 4294967295, 4294967295, 1, 71, 8, 2095, 1, 4294967295, 4294967295, 1, 71, 32, 2096, 1, 4294967295, 4294967295, 3, 71, 8, 2097, 2, 1458, 4294967295, 8, 71, 8, 2099, 1, 4294967295, 4294967295, 1, 71, 8, 2100, 1, 4294967295, 4294967295, 1, 71, 8, 2101, 1, 4294967295, 4294967295, 3, 71, 8, 2102, 2, 1462, 4294967295, 8, 71, 8, 2104, 1, 4294967295, 4294967295, 1, 71, 8, 2105, 1, 4294967295, 4294967295, 3, 71, 8, 2106, 2, 1465, 4294967295, 8, 71, 8, 2108, 1, 4294967295, 4294967295, 1, 71, 8, 2109, 1, 4294967295, 4294967295, 3, 71, 8, 2110, 2, 1468, 4294967295, 8, 71, 8, 2112, 1, 4294967295, 4294967295, 1, 71, 8, 2113, 1, 4294967295, 4294967295, 5, 71, 8, 2114, 1, 1471, 4294967295, 8, 71, 8, 2115, 1, 4294967295, 4294967295, 10, 71, 8, 2116, 2, 4294967295, 4294967295, 12, 71, 8, 2118, 1, 4294967295, 1474, 9, 71, 8, 2119, 1, 4294967295, 4294967295, 1, 71, 32, 2120, 1, 4294967295, 4294967295, 1, 71, 8, 2121, 1, 4294967295, 4294967295, 5, 71, 8, 2122, 1, 1478, 4294967295, 8, 71, 8, 2123, 1, 4294967295, 4294967295, 10, 71, 8, 2124, 2, 4294967295, 4294967295, 12, 71, 8, 2126, 1, 4294967295, 1481, 9, 71, 8, 2127, 1, 4294967295, 4294967295, 1, 71, 32, 2128, 1, 4294967295, 4294967295, 3, 71, 8, 2129, 2, 1484, 4294967295, 8, 71, 8, 2131, 1, 4294967295, 4294967295, 1, 71, 32, 2132, 1, 4294967295, 4294967295, 3, 71, 8, 2133, 2, 1487, 4294967295, 8, 71, 8, 2135, 1, 4294967295, 4294967295, 1, 72, 8, 2136, 1, 4294967295, 4294967295, 5, 72, 8, 2137, 1, 1490, 4294967295, 8, 72, 8, 2138, 1, 4294967295, 4294967295, 10, 72, 8, 2139, 2, 4294967295, 4294967295, 12, 72, 8, 2141, 1, 4294967295, 1493, 9, 72, 8, 2142, 1, 4294967295, 4294967295, 1, 72, 8, 2143, 1, 4294967295, 4294967295, 5, 72, 8, 2144, 1, 1496, 4294967295, 8, 72, 8, 2145, 1, 4294967295, 4294967295, 10, 72, 8, 2146, 2, 4294967295, 4294967295, 12, 72, 8, 2148, 1, 4294967295, 1499, 9, 72, 8, 2149, 1, 4294967295, 4294967295, 1, 72, 32, 2150, 1, 4294967295, 4294967295, 1, 72, 8, 2151, 1, 4294967295, 4294967295, 1, 72, 8, 2152, 1, 4294967295, 4294967295, 3, 72, 8, 2153, 2, 1504, 4294967295, 8, 72, 8, 2155, 1, 4294967295, 4294967295, 1, 72, 8, 2156, 1, 4294967295, 4294967295, 3, 72, 8, 2157, 2, 1507, 4294967295, 8, 72, 8, 2159, 1, 4294967295, 4294967295, 1, 72, 8, 2160, 1, 4294967295, 4294967295, 3, 72, 8, 2161, 2, 1510, 4294967295, 8, 72, 8, 2163, 1, 4294967295, 4294967295, 1, 72, 8, 2164, 1, 4294967295, 4294967295, 5, 72, 8, 2165, 1, 1513, 4294967295, 8, 72, 8, 2166, 1, 4294967295, 4294967295, 10, 72, 8, 2167, 2, 4294967295, 4294967295, 12, 72, 8, 2169, 1, 4294967295, 1516, 9, 72, 8, 2170, 1, 4294967295, 4294967295, 1, 72, 32, 2171, 1, 4294967295, 4294967295, 1, 72, 8, 2172, 1, 4294967295, 4294967295, 5, 72, 8, 2173, 1, 1520, 4294967295, 8, 72, 8, 2174, 1, 4294967295, 4294967295, 10, 72, 8, 2175, 2, 4294967295, 4294967295, 12, 72, 8, 2177, 1, 4294967295, 1523, 9, 72, 8, 2178, 1, 4294967295, 4294967295, 1, 72, 32, 2179, 1, 4294967295, 4294967295, 3, 72, 8, 2180, 2, 1526, 4294967295, 8, 72, 8, 2182, 1, 4294967295, 4294967295, 1, 72, 32, 2183, 1, 4294967295, 4294967295, 3, 72, 8, 2184, 2, 1529, 4294967295, 8, 72, 8, 2186, 1, 4294967295, 4294967295, 1, 73, 8, 2187, 1, 4294967295, 4294967295, 5, 73, 8, 2188, 1, 1532, 4294967295, 8, 73, 8, 2189, 1, 4294967295, 4294967295, 10, 73, 8, 2190, 2, 4294967295, 4294967295, 12, 73, 8, 2192, 1, 4294967295, 1535, 9, 73, 8, 2193, 1, 4294967295, 4294967295, 1, 73, 8, 2194, 1, 4294967295, 4294967295, 5, 73, 8, 2195, 1, 1538, 4294967295, 8, 73, 8, 2196, 1, 4294967295, 4294967295, 10, 73, 8, 2197, 2, 4294967295, 4294967295, 12, 73, 8, 2199, 1, 4294967295, 1541, 9, 73, 8, 2200, 1, 4294967295, 4294967295, 1, 73, 32, 2201, 1, 4294967295, 4294967295, 1, 73, 8, 2202, 1, 4294967295, 4294967295, 1, 73, 8, 2203, 1, 4294967295, 4294967295, 3, 73, 8, 2204, 2, 1546, 4294967295, 8, 73, 8, 2206, 1, 4294967295, 4294967295, 1, 73, 8, 2207, 1, 4294967295, 4294967295, 3, 73, 8, 2208, 2, 1549, 4294967295, 8, 73, 8, 2210, 1, 4294967295, 4294967295, 1, 73, 8, 2211, 1, 4294967295, 4294967295, 3, 73, 8, 2212, 2, 1552, 4294967295, 8, 73, 8, 2214, 1, 4294967295, 4294967295, 1, 73, 8, 2215, 1, 4294967295, 4294967295, 5, 73, 8, 2216, 1, 1555, 4294967295, 8, 73, 8, 2217, 1, 4294967295, 4294967295, 10, 73, 8, 2218, 2, 4294967295, 4294967295, 12, 73, 8, 2220, 1, 4294967295, 1558, 9, 73, 8, 2221, 1, 4294967295, 4294967295, 1, 73, 32, 2222, 1, 4294967295, 4294967295, 1, 73, 8, 2223, 1, 4294967295, 4294967295, 5, 73, 8, 2224, 1, 1562, 4294967295, 8, 73, 8, 2225, 1, 4294967295, 4294967295, 10, 73, 8, 2226, 2, 4294967295, 4294967295, 12, 73, 8, 2228, 1, 4294967295, 1565, 9, 73, 8, 2229, 1, 4294967295, 4294967295, 1, 73, 32, 2230, 1, 4294967295, 4294967295, 3, 73, 8, 2231, 2, 1568, 4294967295, 8, 73, 8, 2233, 1, 4294967295, 4294967295, 1, 73, 32, 2234, 1, 4294967295, 4294967295, 3, 73, 8, 2235, 2, 1571, 4294967295, 8, 73, 8, 2237, 1, 4294967295, 4294967295, 1, 74, 8, 2238, 1, 4294967295, 4294967295, 5, 74, 8, 2239, 1, 1574, 4294967295, 8, 74, 8, 2240, 1, 4294967295, 4294967295, 10, 74, 8, 2241, 2, 4294967295, 4294967295, 12, 74, 8, 2243, 1, 4294967295, 1577, 9, 74, 8, 2244, 1, 4294967295, 4294967295, 1, 74, 8, 2245, 1, 4294967295, 4294967295, 5, 74, 8, 2246, 1, 1580, 4294967295, 8, 74, 8, 2247, 1, 4294967295, 4294967295, 10, 74, 8, 2248, 2, 4294967295, 4294967295, 12, 74, 8, 2250, 1, 4294967295, 1583, 9, 74, 8, 2251, 1, 4294967295, 4294967295, 1, 74, 32, 2252, 1, 4294967295, 4294967295, 1, 74, 8, 2253, 1, 4294967295, 4294967295, 1, 74, 8, 2254, 1, 4294967295, 4294967295, 1, 74, 8, 2255, 1, 4294967295, 4294967295, 3, 74, 8, 2256, 2, 1589, 4294967295, 8, 74, 8, 2258, 1, 4294967295, 4294967295, 1, 74, 8, 2259, 1, 4294967295, 4294967295, 1, 74, 8, 2260, 1, 4294967295, 4294967295, 5, 74, 8, 2261, 1, 1593, 4294967295, 8, 74, 8, 2262, 1, 4294967295, 4294967295, 10, 74, 8, 2263, 2, 4294967295, 4294967295, 12, 74, 8, 2265, 1, 4294967295, 1596, 9, 74, 8, 2266, 1, 4294967295, 4294967295, 1, 74, 32, 2267, 1, 4294967295, 4294967295, 1, 74, 8, 2268, 1, 4294967295, 4294967295, 1, 75, 8, 2269, 1, 4294967295, 4294967295, 5, 75, 8, 2270, 1, 1601, 4294967295, 8, 75, 8, 2271, 1, 4294967295, 4294967295, 10, 75, 8, 2272, 2, 4294967295, 4294967295, 12, 75, 8, 2274, 1, 4294967295, 1604, 9, 75, 8, 2275, 1, 4294967295, 4294967295, 1, 75, 8, 2276, 1, 4294967295, 4294967295, 5, 75, 8, 2277, 1, 1607, 4294967295, 8, 75, 8, 2278, 1, 4294967295, 4294967295, 10, 75, 8, 2279, 2, 4294967295, 4294967295, 12, 75, 8, 2281, 1, 4294967295, 1610, 9, 75, 8, 2282, 1, 4294967295, 4294967295, 1, 75, 8, 2283, 1, 4294967295, 4294967295, 1, 75, 8, 2284, 1, 4294967295, 4294967295, 1, 76, 72, 2285, 1, 4294967295, 4294967295, 1, 76, 8, 2286, 1, 4294967295, 4294967295, 1, 76, 8, 2287, 1, 4294967295, 4294967295, 1, 76, 8, 2288, 1, 4294967295, 4294967295, 1, 76, 8, 2289, 1, 4294967295, 4294967295, 1, 76, 8, 2290, 1, 4294967295, 4294967295, 1, 76, 8, 2291, 1, 4294967295, 4294967295, 3, 76, 8, 2292, 6, 1621, 4294967295, 8, 76, 8, 2298, 1, 4294967295, 4294967295, 1, 76, 72, 2299, 1, 4294967295, 4294967295, 1, 76, 8, 2300, 1, 4294967295, 4294967295, 4, 76, 8, 2301, 1, 1625, 4294967295, 8, 76, 8, 2302, 1, 4294967295, 4294967295, 11, 76, 8, 2303, 2, 4294967295, 4294967295, 12, 76, 8, 2305, 1, 4294967295, 1626, 1, 76, 72, 2306, 1, 4294967295, 4294967295, 1, 76, 32, 2307, 1, 4294967295, 4294967295, 1, 76, 72, 2308, 1, 4294967295, 4294967295, 1, 76, 32, 2309, 1, 4294967295, 4294967295, 5, 76, 8, 2310, 3, 1633, 4294967295, 8, 76, 8, 2313, 1, 4294967295, 4294967295, 10, 76, 10, 2314, 2, 4294967295, 4294967295, 12, 76, 8, 2316, 1, 4294967295, 1636, 9, 76, 8, 2317, 1, 4294967295, 4294967295, 1, 77, 8, 2318, 1, 4294967295, 4294967295, 1, 77, 8, 2319, 1, 4294967295, 4294967295, 4, 77, 8, 2320, 1, 1640, 4294967295, 8, 77, 8, 2321, 1, 4294967295, 4294967295, 11, 77, 8, 2322, 2, 4294967295, 4294967295, 12, 77, 8, 2324, 1, 4294967295, 1641, 1, 78, 32, 2325, 1, 4294967295, 4294967295, 1, 78, 8, 2326, 1, 4294967295, 4294967295, 3, 78, 8, 2327, 2, 1646, 4294967295, 8, 78, 8, 2329, 1, 4294967295, 4294967295, 1, 78, 32, 2330, 1, 4294967295, 4294967295, 1, 78, 8, 2331, 1, 4294967295, 4294967295, 3, 78, 8, 2332, 2, 1650, 4294967295, 8, 78, 8, 2334, 1, 4294967295, 4294967295, 5, 78, 8, 2335, 1, 1652, 4294967295, 8, 78, 8, 2336, 1, 4294967295, 4294967295, 10, 78, 8, 2337, 2, 4294967295, 4294967295, 12, 78, 8, 2339, 1, 4294967295, 1655, 9, 78, 8, 2340, 1, 4294967295, 4294967295, 3, 78, 8, 2341, 2, 1657, 4294967295, 8, 78, 8, 2343, 1, 4294967295, 4294967295, 1, 78, 32, 2344, 1, 4294967295, 4294967295, 1, 78, 8, 2345, 1, 4294967295, 4294967295, 1, 79, 32, 2346, 1, 4294967295, 4294967295, 1, 79, 32, 2347, 1, 4294967295, 4294967295, 1, 79, 8, 2348, 1, 4294967295, 4294967295, 3, 79, 8, 2349, 2, 1664, 4294967295, 8, 79, 8, 2351, 1, 4294967295, 4294967295, 1, 79, 8, 2352, 1, 4294967295, 4294967295, 1, 79, 8, 2353, 1, 4294967295, 4294967295, 1, 80, 32, 2354, 1, 4294967295, 4294967295, 1, 80, 8, 2355, 1, 4294967295, 4294967295, 3, 80, 8, 2356, 2, 1670, 4294967295, 8, 80, 8, 2358, 1, 4294967295, 4294967295, 1, 80, 32, 2359, 1, 4294967295, 4294967295, 1, 80, 8, 2360, 1, 4294967295, 4294967295, 3, 80, 8, 2361, 2, 1674, 4294967295, 8, 80, 8, 2363, 1, 4294967295, 4294967295, 3, 80, 8, 2364, 2, 1676, 4294967295, 8, 80, 8, 2366, 1, 4294967295, 4294967295, 1, 81, 32, 2367, 1, 4294967295, 4294967295, 1, 81, 8, 2368, 1, 4294967295, 4294967295, 1, 81, 32, 2369, 1, 4294967295, 4294967295, 1, 81, 8, 2370, 1, 4294967295, 4294967295, 5, 81, 8, 2371, 1, 1682, 4294967295, 8, 81, 8, 2372, 1, 4294967295, 4294967295, 10, 81, 8, 2373, 2, 4294967295, 4294967295, 12, 81, 8, 2375, 1, 4294967295, 1685, 9, 81, 8, 2376, 1, 4294967295, 4294967295, 1, 81, 32, 2377, 1, 4294967295, 4294967295, 1, 81, 8, 2378, 1, 4294967295, 4294967295, 1, 82, 8, 2379, 1, 4294967295, 4294967295, 1, 82, 8, 2380, 1, 4294967295, 4294967295, 1, 83, 32, 2381, 1, 4294967295, 4294967295, 1, 83, 8, 2382, 1, 4294967295, 4294967295, 1, 83, 32, 2383, 1, 4294967295, 4294967295, 1, 83, 8, 2384, 1, 4294967295, 4294967295, 5, 83, 8, 2385, 1, 1695, 4294967295, 8, 83, 8, 2386, 1, 4294967295, 4294967295, 10, 83, 8, 2387, 2, 4294967295, 4294967295, 12, 83, 8, 2389, 1, 4294967295, 1698, 9, 83, 8, 2390, 1, 4294967295, 4294967295, 1, 83, 32, 2391, 1, 4294967295, 4294967295, 1, 83, 8, 2392, 1, 4294967295, 4294967295, 1, 84, 8, 2393, 1, 4294967295, 4294967295, 5, 84, 8, 2394, 1, 1703, 4294967295, 8, 84, 8, 2395, 1, 4294967295, 4294967295, 10, 84, 8, 2396, 2, 4294967295, 4294967295, 12, 84, 8, 2398, 1, 4294967295, 1706, 9, 84, 8, 2399, 1, 4294967295, 4294967295, 1, 84, 8, 2400, 1, 4294967295, 4294967295, 5, 84, 8, 2401, 1, 1709, 4294967295, 8, 84, 8, 2402, 1, 4294967295, 4294967295, 10, 84, 8, 2403, 2, 4294967295, 4294967295, 12, 84, 8, 2405, 1, 4294967295, 1712, 9, 84, 8, 2406, 1, 4294967295, 4294967295, 1, 84, 8, 2407, 1, 4294967295, 4294967295, 1, 84, 8, 2408, 1, 4294967295, 4294967295, 1, 85, 32, 2409, 1, 4294967295, 4294967295, 1, 85, 8, 2410, 1, 4294967295, 4294967295, 1, 86, 32, 2411, 1, 4294967295, 4294967295, 1, 86, 32, 2412, 1, 4294967295, 4294967295, 3, 86, 8, 2413, 2, 1720, 4294967295, 8, 86, 8, 2415, 1, 4294967295, 4294967295, 1, 86, 8, 2416, 1, 4294967295, 4294967295, 1, 86, 8, 2417, 1, 4294967295, 4294967295, 1, 87, 32, 2418, 1, 4294967295, 4294967295, 1, 87, 8, 2419, 1, 4294967295, 4294967295, 1, 87, 8, 2420, 1, 4294967295, 4294967295, 1, 88, 32, 2421, 1, 4294967295, 4294967295, 1, 88, 8, 2422, 1, 4294967295, 4294967295, 1, 88, 32, 2423, 1, 4294967295, 4294967295, 1, 88, 8, 2424, 1, 4294967295, 4294967295, 4, 88, 8, 2425, 1, 1731, 4294967295, 8, 88, 8, 2426, 1, 4294967295, 4294967295, 11, 88, 8, 2427, 2, 4294967295, 4294967295, 12, 88, 8, 2429, 1, 4294967295, 1732, 1, 88, 32, 2430, 1, 4294967295, 4294967295, 1, 88, 8, 2431, 1, 4294967295, 4294967295, 1, 89, 8, 2432, 1, 4294967295, 4294967295, 1, 89, 8, 2433, 1, 4294967295, 4294967295, 3, 89, 8, 2434, 2, 1739, 4294967295, 8, 89, 8, 2436, 1, 4294967295, 4294967295, 1, 90, 8, 2437, 1, 4294967295, 4294967295, 1, 90, 8, 2438, 1, 4294967295, 4294967295, 1, 90, 8, 2439, 1, 4294967295, 4294967295, 1, 90, 8, 2440, 1, 4294967295, 4294967295, 1, 90, 8, 2441, 1, 4294967295, 4294967295, 1, 90, 8, 2442, 1, 4294967295, 4294967295, 1, 90, 8, 2443, 1, 4294967295, 4294967295, 1, 90, 8, 2444, 1, 4294967295, 4294967295, 1, 90, 8, 2445, 1, 4294967295, 4294967295, 1, 90, 8, 2446, 1, 4294967295, 4294967295, 1, 90, 8, 2447, 1, 4294967295, 4294967295, 1, 90, 8, 2448, 1, 4294967295, 4294967295, 1, 90, 8, 2449, 1, 4294967295, 4294967295, 1, 90, 8, 2450, 1, 4294967295, 4294967295, 1, 90, 8, 2451, 1, 4294967295, 4294967295, 1, 90, 8, 2452, 1, 4294967295, 4294967295, 1, 90, 8, 2453, 1, 4294967295, 4294967295, 1, 90, 8, 2454, 1, 4294967295, 4294967295, 1, 90, 8, 2455, 1, 4294967295, 4294967295, 1, 90, 8, 2456, 1, 4294967295, 4294967295, 1, 90, 8, 2457, 1, 4294967295, 4294967295, 1, 90, 8, 2458, 1, 4294967295, 4294967295, 1, 90, 8, 2459, 1, 4294967295, 4294967295, 1, 90, 8, 2460, 1, 4294967295, 4294967295, 3, 90, 8, 2461, 24, 1765, 4294967295, 8, 90, 8, 2485, 1, 4294967295, 4294967295, 1, 91, 8, 2486, 1, 4294967295, 4294967295, 5, 91, 8, 2487, 1, 1768, 4294967295, 8, 91, 8, 2488, 1, 4294967295, 4294967295, 10, 91, 8, 2489, 2, 4294967295, 4294967295, 12, 91, 8, 2491, 1, 4294967295, 1771, 9, 91, 8, 2492, 1, 4294967295, 4294967295, 1, 91, 32, 2493, 1, 4294967295, 4294967295, 1, 91, 8, 2494, 1, 4294967295, 4294967295, 3, 91, 8, 2495, 2, 1775, 4294967295, 8, 91, 8, 2497, 1, 4294967295, 4294967295, 1, 91, 32, 2498, 1, 4294967295, 4294967295, 1, 91, 8, 2499, 1, 4294967295, 4294967295, 1, 92, 8, 2500, 1, 4294967295, 4294967295, 5, 92, 8, 2501, 1, 1780, 4294967295, 8, 92, 8, 2502, 1, 4294967295, 4294967295, 10, 92, 8, 2503, 2, 4294967295, 4294967295, 12, 92, 8, 2505, 1, 4294967295, 1783, 9, 92, 8, 2506, 1, 4294967295, 4294967295, 1, 92, 32, 2507, 1, 4294967295, 4294967295, 1, 92, 8, 2508, 1, 4294967295, 4294967295, 1, 92, 8, 2509, 1, 4294967295, 4294967295, 1, 93, 8, 2510, 1, 4294967295, 4294967295, 1, 93, 8, 2511, 1, 4294967295, 4294967295, 3, 93, 8, 2512, 2, 1790, 4294967295, 8, 93, 8, 2514, 1, 4294967295, 4294967295, 1, 94, 8, 2515, 1, 4294967295, 4294967295, 5, 94, 8, 2516, 1, 1793, 4294967295, 8, 94, 8, 2517, 1, 4294967295, 4294967295, 10, 94, 8, 2518, 2, 4294967295, 4294967295, 12, 94, 8, 2520, 1, 4294967295, 1796, 9, 94, 8, 2521, 1, 4294967295, 4294967295, 1, 94, 32, 2522, 1, 4294967295, 4294967295, 3, 94, 8, 2523, 2, 1799, 4294967295, 8, 94, 8, 2525, 1, 4294967295, 4294967295, 1, 94, 32, 2526, 1, 4294967295, 4294967295, 1, 94, 32, 2527, 1, 4294967295, 4294967295, 1, 94, 8, 2528, 1, 4294967295, 4294967295, 1, 94, 8, 2529, 1, 4294967295, 4294967295, 1, 94, 32, 2530, 1, 4294967295, 4294967295, 1, 94, 8, 2531, 1, 4294967295, 4294967295, 1, 94, 32, 2532, 1, 4294967295, 4294967295, 1, 94, 8, 2533, 1, 4294967295, 4294967295, 1, 94, 8, 2534, 1, 4294967295, 4294967295, 1, 95, 8, 2535, 1, 4294967295, 4294967295, 5, 95, 8, 2536, 1, 1811, 4294967295, 8, 95, 8, 2537, 1, 4294967295, 4294967295, 10, 95, 8, 2538, 2, 4294967295, 4294967295, 12, 95, 8, 2540, 1, 4294967295, 1814, 9, 95, 8, 2541, 1, 4294967295, 4294967295, 1, 95, 32, 2542, 1, 4294967295, 4294967295, 3, 95, 8, 2543, 2, 1817, 4294967295, 8, 95, 8, 2545, 1, 4294967295, 4294967295, 1, 95, 32, 2546, 1, 4294967295, 4294967295, 1, 95, 32, 2547, 1, 4294967295, 4294967295, 1, 95, 8, 2548, 1, 4294967295, 4294967295, 1, 95, 32, 2549, 1, 4294967295, 4294967295, 1, 95, 8, 2550, 1, 4294967295, 4294967295, 1, 95, 32, 2551, 1, 4294967295, 4294967295, 1, 95, 8, 2552, 1, 4294967295, 4294967295, 1, 95, 8, 2553, 1, 4294967295, 4294967295, 1, 96, 8, 2554, 1, 4294967295, 4294967295, 5, 96, 8, 2555, 1, 1828, 4294967295, 8, 96, 8, 2556, 1, 4294967295, 4294967295, 10, 96, 8, 2557, 2, 4294967295, 4294967295, 12, 96, 8, 2559, 1, 4294967295, 1831, 9, 96, 8, 2560, 1, 4294967295, 4294967295, 1, 96, 32, 2561, 1, 4294967295, 4294967295, 1, 96, 8, 2562, 1, 4294967295, 4294967295, 3, 96, 8, 2563, 2, 1835, 4294967295, 8, 96, 8, 2565, 1, 4294967295, 4294967295, 1, 96, 32, 2566, 1, 4294967295, 4294967295, 1, 96, 8, 2567, 1, 4294967295, 4294967295, 1, 97, 8, 2568, 1, 4294967295, 4294967295, 5, 97, 8, 2569, 1, 1840, 4294967295, 8, 97, 8, 2570, 1, 4294967295, 4294967295, 10, 97, 8, 2571, 2, 4294967295, 4294967295, 12, 97, 8, 2573, 1, 4294967295, 1843, 9, 97, 8, 2574, 1, 4294967295, 4294967295, 1, 97, 32, 2575, 1, 4294967295, 4294967295, 1, 97, 8, 2576, 1, 4294967295, 4294967295, 1, 97, 32, 2577, 1, 4294967295, 4294967295, 1, 97, 32, 2578, 1, 4294967295, 4294967295, 1, 97, 8, 2579, 1, 4294967295, 4294967295, 1, 97, 32, 2580, 1, 4294967295, 4294967295, 1, 97, 32, 2581, 1, 4294967295, 4294967295, 1, 97, 8, 2582, 1, 4294967295, 4294967295, 1, 98, 8, 2583, 1, 4294967295, 4294967295, 5, 98, 8, 2584, 1, 1854, 4294967295, 8, 98, 8, 2585, 1, 4294967295, 4294967295, 10, 98, 8, 2586, 2, 4294967295, 4294967295, 12, 98, 8, 2588, 1, 4294967295, 1857, 9, 98, 8, 2589, 1, 4294967295, 4294967295, 1, 98, 32, 2590, 1, 4294967295, 4294967295, 1, 98, 8, 2591, 1, 4294967295, 4294967295, 1, 99, 8, 2592, 1, 4294967295, 4294967295, 5, 99, 8, 2593, 1, 1862, 4294967295, 8, 99, 8, 2594, 1, 4294967295, 4294967295, 10, 99, 8, 2595, 2, 4294967295, 4294967295, 12, 99, 8, 2597, 1, 4294967295, 1865, 9, 99, 8, 2598, 1, 4294967295, 4294967295, 1, 99, 8, 2599, 1, 4294967295, 4294967295, 1, 99, 32, 2600, 1, 4294967295, 4294967295, 1, 99, 8, 2601, 1, 4294967295, 4294967295, 1, 100, 8, 2602, 1, 4294967295, 4294967295, 5, 100, 8, 2603, 1, 1871, 4294967295, 8, 100, 8, 2604, 1, 4294967295, 4294967295, 10, 100, 8, 2605, 2, 4294967295, 4294967295, 12, 100, 8, 2607, 1, 4294967295, 1874, 9, 100, 8, 2608, 1, 4294967295, 4294967295, 1, 100, 32, 2609, 1, 4294967295, 4294967295, 1, 100, 32, 2610, 1, 4294967295, 4294967295, 1, 100, 8, 2611, 1, 4294967295, 4294967295, 1, 100, 32, 2612, 1, 4294967295, 4294967295, 1, 100, 8, 2613, 1, 4294967295, 4294967295, 1, 100, 8, 2614, 1, 4294967295, 4294967295, 1, 101, 8, 2615, 1, 4294967295, 4294967295, 5, 101, 8, 2616, 1, 1883, 4294967295, 8, 101, 8, 2617, 1, 4294967295, 4294967295, 10, 101, 8, 2618, 2, 4294967295, 4294967295, 12, 101, 8, 2620, 1, 4294967295, 1886, 9, 101, 8, 2621, 1, 4294967295, 4294967295, 1, 101, 32, 2622, 1, 4294967295, 4294967295, 1, 101, 32, 2623, 1, 4294967295, 4294967295, 1, 101, 8, 2624, 1, 4294967295, 4294967295, 3, 101, 8, 2625, 2, 1891, 4294967295, 8, 101, 8, 2627, 1, 4294967295, 4294967295, 1, 101, 8, 2628, 1, 4294967295, 4294967295, 1, 101, 32, 2629, 1, 4294967295, 4294967295, 1, 101, 8, 2630, 1, 4294967295, 4294967295, 5, 101, 8, 2631, 1, 1896, 4294967295, 8, 101, 8, 2632, 1, 4294967295, 4294967295, 10, 101, 8, 2633, 2, 4294967295, 4294967295, 12, 101, 8, 2635, 1, 4294967295, 1899, 9, 101, 8, 2636, 1, 4294967295, 4294967295, 3, 101, 8, 2637, 2, 1901, 4294967295, 8, 101, 8, 2639, 1, 4294967295, 4294967295, 3, 101, 8, 2640, 2, 1903, 4294967295, 8, 101, 8, 2642, 1, 4294967295, 4294967295, 1, 101, 32, 2643, 1, 4294967295, 4294967295, 1, 101, 8, 2644, 1, 4294967295, 4294967295, 3, 101, 8, 2645, 2, 1907, 4294967295, 8, 101, 8, 2647, 1, 4294967295, 4294967295, 1, 101, 32, 2648, 1, 4294967295, 4294967295, 1, 101, 8, 2649, 1, 4294967295, 4294967295, 1, 101, 32, 2650, 1, 4294967295, 4294967295, 1, 101, 8, 2651, 1, 4294967295, 4294967295, 5, 101, 8, 2652, 1, 1913, 4294967295, 8, 101, 8, 2653, 1, 4294967295, 4294967295, 10, 101, 8, 2654, 2, 4294967295, 4294967295, 12, 101, 8, 2656, 1, 4294967295, 1916, 9, 101, 8, 2657, 1, 4294967295, 4294967295, 3, 101, 8, 2658, 2, 1918, 4294967295, 8, 101, 8, 2660, 1, 4294967295, 4294967295, 1, 101, 32, 2661, 1, 4294967295, 4294967295, 1, 101, 8, 2662, 1, 4294967295, 4294967295, 1, 101, 8, 2663, 1, 4294967295, 4294967295, 1, 102, 8, 2664, 1, 4294967295, 4294967295, 5, 102, 8, 2665, 1, 1924, 4294967295, 8, 102, 8, 2666, 1, 4294967295, 4294967295, 10, 102, 8, 2667, 2, 4294967295, 4294967295, 12, 102, 8, 2669, 1, 4294967295, 1927, 9, 102, 8, 2670, 1, 4294967295, 4294967295, 1, 102, 32, 2671, 1, 4294967295, 4294967295, 1, 102, 32, 2672, 1, 4294967295, 4294967295, 3, 102, 8, 2673, 2, 1931, 4294967295, 8, 102, 8, 2675, 1, 4294967295, 4294967295, 1, 102, 8, 2676, 1, 4294967295, 4294967295, 3, 102, 8, 2677, 2, 1934, 4294967295, 8, 102, 8, 2679, 1, 4294967295, 4294967295, 1, 102, 32, 2680, 1, 4294967295, 4294967295, 1, 102, 8, 2681, 1, 4294967295, 4294967295, 1, 103, 8, 2682, 1, 4294967295, 4294967295, 5, 103, 8, 2683, 1, 1939, 4294967295, 8, 103, 8, 2684, 1, 4294967295, 4294967295, 10, 103, 8, 2685, 2, 4294967295, 4294967295, 12, 103, 8, 2687, 1, 4294967295, 1942, 9, 103, 8, 2688, 1, 4294967295, 4294967295, 1, 103, 32, 2689, 1, 4294967295, 4294967295, 1, 103, 32, 2690, 1, 4294967295, 4294967295, 1, 103, 8, 2691, 1, 4294967295, 4294967295, 1, 103, 32, 2692, 1, 4294967295, 4294967295, 1, 103, 8, 2693, 1, 4294967295, 4294967295, 1, 103, 8, 2694, 1, 4294967295, 4294967295, 3, 103, 8, 2695, 2, 1950, 4294967295, 8, 103, 8, 2697, 1, 4294967295, 4294967295, 1, 104, 32, 2698, 1, 4294967295, 4294967295, 1, 104, 8, 2699, 1, 4294967295, 4294967295, 1, 104, 8, 2700, 1, 4294967295, 4294967295, 1, 105, 8, 2701, 1, 4294967295, 4294967295, 5, 105, 8, 2702, 1, 1956, 4294967295, 8, 105, 8, 2703, 1, 4294967295, 4294967295, 10, 105, 8, 2704, 2, 4294967295, 4294967295, 12, 105, 8, 2706, 1, 4294967295, 1959, 9, 105, 8, 2707, 1, 4294967295, 4294967295, 1, 105, 8, 2708, 1, 4294967295, 4294967295, 1, 105, 32, 2709, 1, 4294967295, 4294967295, 1, 105, 8, 2710, 1, 4294967295, 4294967295, 1, 105, 8, 2711, 1, 4294967295, 4294967295, 1, 106, 8, 2712, 1, 4294967295, 4294967295, 5, 106, 8, 2713, 1, 1966, 4294967295, 8, 106, 8, 2714, 1, 4294967295, 4294967295, 10, 106, 8, 2715, 2, 4294967295, 4294967295, 12, 106, 8, 2717, 1, 4294967295, 1969, 9, 106, 8, 2718, 1, 4294967295, 4294967295, 1, 106, 32, 2719, 1, 4294967295, 4294967295, 3, 106, 8, 2720, 2, 1972, 4294967295, 8, 106, 8, 2722, 1, 4294967295, 4294967295, 1, 106, 32, 2723, 1, 4294967295, 4294967295, 3, 106, 8, 2724, 2, 1975, 4294967295, 8, 106, 8, 2726, 1, 4294967295, 4294967295, 1, 106, 8, 2727, 1, 4294967295, 4294967295, 5, 106, 8, 2728, 1, 1978, 4294967295, 8, 106, 8, 2729, 1, 4294967295, 4294967295, 10, 106, 8, 2730, 2, 4294967295, 4294967295, 12, 106, 8, 2732, 1, 4294967295, 1981, 9, 106, 8, 2733, 1, 4294967295, 4294967295, 1, 106, 8, 2734, 1, 4294967295, 4294967295, 1, 106, 32, 2735, 1, 4294967295, 4294967295, 1, 106, 8, 2736, 1, 4294967295, 4294967295, 1, 107, 8, 2737, 1, 4294967295, 4294967295, 5, 107, 8, 2738, 1, 1987, 4294967295, 8, 107, 8, 2739, 1, 4294967295, 4294967295, 10, 107, 8, 2740, 2, 4294967295, 4294967295, 12, 107, 8, 2742, 1, 4294967295, 1990, 9, 107, 8, 2743, 1, 4294967295, 4294967295, 1, 107, 8, 2744, 1, 4294967295, 4294967295, 5, 107, 8, 2745, 1, 1993, 4294967295, 8, 107, 8, 2746, 1, 4294967295, 4294967295, 10, 107, 8, 2747, 2, 4294967295, 4294967295, 12, 107, 8, 2749, 1, 4294967295, 1996, 9, 107, 8, 2750, 1, 4294967295, 4294967295, 1, 107, 8, 2751, 1, 4294967295, 4294967295, 1, 107, 8, 2752, 1, 4294967295, 4294967295, 1, 107, 8, 2753, 1, 4294967295, 4294967295, 3, 107, 8, 2754, 2, 2001, 4294967295, 8, 107, 8, 2756, 1, 4294967295, 4294967295, 1, 107, 8, 2757, 1, 4294967295, 4294967295, 1, 107, 8, 2758, 1, 4294967295, 4294967295, 5, 107, 8, 2759, 1, 2005, 4294967295, 8, 107, 8, 2760, 1, 4294967295, 4294967295, 10, 107, 8, 2761, 2, 4294967295, 4294967295, 12, 107, 8, 2763, 1, 4294967295, 2008, 9, 107, 8, 2764, 1, 4294967295, 4294967295, 1, 107, 8, 2765, 1, 4294967295, 4294967295, 1, 107, 8, 2766, 1, 4294967295, 4294967295, 1, 107, 32, 2767, 1, 4294967295, 4294967295, 1, 107, 8, 2768, 1, 4294967295, 4294967295, 3, 107, 8, 2769, 2, 2014, 4294967295, 8, 107, 8, 2771, 1, 4294967295, 4294967295, 1, 108, 8, 2772, 1, 4294967295, 4294967295, 5, 108, 8, 2773, 1, 2017, 4294967295, 8, 108, 8, 2774, 1, 4294967295, 4294967295, 10, 108, 8, 2775, 2, 4294967295, 4294967295, 12, 108, 8, 2777, 1, 4294967295, 2020, 9, 108, 8, 2778, 1, 4294967295, 4294967295, 1, 108, 32, 2779, 1, 4294967295, 4294967295, 1, 108, 32, 2780, 1, 4294967295, 4294967295, 1, 108, 8, 2781, 1, 4294967295, 4294967295, 1, 108, 32, 2782, 1, 4294967295, 4294967295, 1, 108, 8, 2783, 1, 4294967295, 4294967295, 1, 108, 8, 2784, 1, 4294967295, 4294967295, 1, 109, 8, 2785, 1, 4294967295, 4294967295, 5, 109, 8, 2786, 1, 2029, 4294967295, 8, 109, 8, 2787, 1, 4294967295, 4294967295, 10, 109, 8, 2788, 2, 4294967295, 4294967295, 12, 109, 8, 2790, 1, 4294967295, 2032, 9, 109, 8, 2791, 1, 4294967295, 4294967295, 1, 109, 32, 2792, 1, 4294967295, 4294967295, 1, 109, 8, 2793, 1, 4294967295, 4294967295, 3, 109, 8, 2794, 2, 2036, 4294967295, 8, 109, 8, 2796, 1, 4294967295, 4294967295, 1, 109, 32, 2797, 1, 4294967295, 4294967295, 1, 109, 8, 2798, 1, 4294967295, 4294967295, 1, 110, 8, 2799, 1, 4294967295, 4294967295, 5, 110, 8, 2800, 1, 2041, 4294967295, 8, 110, 8, 2801, 1, 4294967295, 4294967295, 10, 110, 8, 2802, 2, 4294967295, 4294967295, 12, 110, 8, 2804, 1, 4294967295, 2044, 9, 110, 8, 2805, 1, 4294967295, 4294967295, 1, 110, 32, 2806, 1, 4294967295, 4294967295, 1, 110, 32, 2807, 1, 4294967295, 4294967295, 1, 110, 8, 2808, 1, 4294967295, 4294967295, 1, 110, 32, 2809, 1, 4294967295, 4294967295, 1, 110, 32, 2810, 1, 4294967295, 4294967295, 1, 110, 8, 2811, 1, 4294967295, 4294967295, 5, 110, 8, 2812, 1, 2052, 4294967295, 8, 110, 8, 2813, 1, 4294967295, 4294967295, 10, 110, 8, 2814, 2, 4294967295, 4294967295, 12, 110, 8, 2816, 1, 4294967295, 2055, 9, 110, 8, 2817, 1, 4294967295, 4294967295, 1, 110, 32, 2818, 1, 4294967295, 4294967295, 1, 110, 8, 2819, 1, 4294967295, 4294967295, 1, 111, 8, 2820, 1, 4294967295, 4294967295, 4, 111, 8, 2821, 1, 2060, 4294967295, 8, 111, 8, 2822, 1, 4294967295, 4294967295, 11, 111, 8, 2823, 2, 4294967295, 4294967295, 12, 111, 8, 2825, 1, 4294967295, 2061, 1, 111, 8, 2826, 1, 4294967295, 4294967295, 4, 111, 8, 2827, 1, 2065, 4294967295, 8, 111, 8, 2828, 1, 4294967295, 4294967295, 11, 111, 8, 2829, 2, 4294967295, 4294967295, 12, 111, 8, 2831, 1, 4294967295, 2066, 1, 112, 8, 2832, 1, 4294967295, 4294967295, 1, 112, 8, 2833, 1, 4294967295, 4294967295, 1, 112, 8, 2834, 1, 4294967295, 4294967295, 3, 112, 8, 2835, 3, 2072, 4294967295, 8, 112, 8, 2838, 1, 4294967295, 4294967295, 1, 113, 32, 2839, 1, 4294967295, 4294967295, 1, 113, 8, 2840, 1, 4294967295, 4294967295, 1, 113, 8, 2841, 1, 4294967295, 4294967295, 3, 113, 8, 2842, 2, 2077, 4294967295, 8, 113, 8, 2844, 1, 4294967295, 4294967295, 1, 113, 32, 2845, 1, 4294967295, 4294967295, 1, 113, 8, 2846, 1, 4294967295, 4294967295, 1, 114, 72, 2847, 1, 4294967295, 4294967295, 1, 114, 8, 2848, 1, 4294967295, 4294967295, 1, 114, 8, 2849, 1, 4294967295, 4294967295, 1, 114, 8, 2850, 1, 4294967295, 4294967295, 1, 114, 8, 2851, 1, 4294967295, 4294967295, 1, 114, 8, 2852, 1, 4294967295, 4294967295, 1, 114, 8, 2853, 1, 4294967295, 4294967295, 1, 114, 8, 2854, 1, 4294967295, 4294967295, 1, 114, 8, 2855, 1, 4294967295, 4294967295, 1, 114, 8, 2856, 1, 4294967295, 4294967295, 1, 114, 8, 2857, 1, 4294967295, 4294967295, 1, 114, 8, 2858, 1, 4294967295, 4294967295, 3, 114, 8, 2859, 11, 2093, 4294967295, 8, 114, 8, 2870, 1, 4294967295, 4294967295, 1, 114, 72, 2871, 1, 4294967295, 4294967295, 1, 114, 32, 2872, 1, 4294967295, 4294967295, 1, 114, 8, 2873, 1, 4294967295, 4294967295, 5, 114, 8, 2874, 1, 2098, 4294967295, 8, 114, 8, 2875, 1, 4294967295, 4294967295, 10, 114, 10, 2876, 2, 4294967295, 4294967295, 12, 114, 8, 2878, 1, 4294967295, 2101, 9, 114, 8, 2879, 1, 4294967295, 4294967295, 1, 115, 8, 2880, 1, 4294967295, 4294967295, 1, 115, 8, 2881, 1, 4294967295, 4294967295, 1, 116, 8, 2882, 1, 4294967295, 4294967295, 1, 116, 8, 2883, 1, 4294967295, 4294967295, 1, 116, 8, 2884, 1, 4294967295, 4294967295, 1, 117, 8, 2885, 1, 4294967295, 4294967295, 1, 117, 8, 2886, 1, 4294967295, 4294967295, 1, 117, 8, 2887, 1, 4294967295, 4294967295, 3, 117, 8, 2888, 3, 2111, 4294967295, 8, 117, 8, 2891, 1, 4294967295, 4294967295, 1, 118, 32, 2892, 1, 4294967295, 4294967295, 1, 118, 8, 2893, 1, 4294967295, 4294967295, 1, 119, 32, 2894, 1, 4294967295, 4294967295, 1, 119, 8, 2895, 1, 4294967295, 4294967295, 1, 119, 32, 2896, 1, 4294967295, 4294967295, 1, 119, 8, 2897, 1, 4294967295, 4294967295, 5, 119, 8, 2898, 1, 2119, 4294967295, 8, 119, 8, 2899, 1, 4294967295, 4294967295, 10, 119, 8, 2900, 2, 4294967295, 4294967295, 12, 119, 8, 2902, 1, 4294967295, 2122, 9, 119, 8, 2903, 1, 4294967295, 4294967295, 3, 119, 8, 2904, 2, 2124, 4294967295, 8, 119, 8, 2906, 1, 4294967295, 4294967295, 1, 119, 32, 2907, 1, 4294967295, 4294967295, 1, 119, 8, 2908, 1, 4294967295, 4294967295, 1, 120, 32, 2909, 1, 4294967295, 4294967295, 1, 120, 8, 2910, 1, 4294967295, 4294967295, 1, 121, 32, 2911, 1, 4294967295, 4294967295, 1, 121, 8, 2912, 1, 4294967295, 4294967295, 1, 122, 32, 2913, 1, 4294967295, 4294967295, 1, 122, 8, 2914, 1, 4294967295, 4294967295, 1, 122, 32, 2915, 1, 4294967295, 4294967295, 1, 122, 8, 2916, 1, 4294967295, 4294967295, 5, 122, 8, 2917, 1, 2136, 4294967295, 8, 122, 8, 2918, 1, 4294967295, 4294967295, 10, 122, 8, 2919, 2, 4294967295, 4294967295, 12, 122, 8, 2921, 1, 4294967295, 2139, 9, 122, 8, 2922, 1, 4294967295, 4294967295, 1, 122, 32, 2923, 1, 4294967295, 4294967295, 3, 122, 8, 2924, 2, 2142, 4294967295, 8, 122, 8, 2926, 1, 4294967295, 4294967295, 3, 122, 8, 2927, 2, 2144, 4294967295, 8, 122, 8, 2929, 1, 4294967295, 4294967295, 1, 122, 32, 2930, 1, 4294967295, 4294967295, 1, 122, 8, 2931, 1, 4294967295, 4294967295, 3, 122, 8, 2932, 2, 2148, 4294967295, 8, 122, 8, 2934, 1, 4294967295, 4294967295, 1, 123, 32, 2935, 1, 4294967295, 4294967295, 1, 123, 8, 2936, 1, 4294967295, 4294967295, 1, 123, 32, 2937, 1, 4294967295, 4294967295, 1, 123, 8, 2938, 1, 4294967295, 4294967295, 1, 124, 8, 2939, 1, 4294967295, 4294967295, 3, 124, 8, 2940, 2, 2155, 4294967295, 8, 124, 8, 2942, 1, 4294967295, 4294967295, 1, 124, 8, 2943, 1, 4294967295, 4294967295, 3, 124, 8, 2944, 2, 2158, 4294967295, 8, 124, 8, 2946, 1, 4294967295, 4294967295, 1, 124, 8, 2947, 1, 4294967295, 4294967295, 3, 124, 8, 2948, 2, 2161, 4294967295, 8, 124, 8, 2950, 1, 4294967295, 4294967295, 1, 124, 8, 2951, 1, 4294967295, 4294967295, 3, 124, 8, 2952, 2, 2164, 4294967295, 8, 124, 8, 2954, 1, 4294967295, 4294967295, 1, 125, 32, 2955, 1, 4294967295, 4294967295, 1, 125, 8, 2956, 1, 4294967295, 4294967295, 1, 125, 32, 2957, 1, 4294967295, 4294967295, 1, 125, 8, 2958, 1, 4294967295, 4294967295, 5, 125, 8, 2959, 1, 2170, 4294967295, 8, 125, 8, 2960, 1, 4294967295, 4294967295, 10, 125, 8, 2961, 2, 4294967295, 4294967295, 12, 125, 8, 2963, 1, 4294967295, 2173, 9, 125, 8, 2964, 1, 4294967295, 4294967295, 3, 125, 8, 2965, 2, 2175, 4294967295, 8, 125, 8, 2967, 1, 4294967295, 4294967295, 1, 125, 32, 2968, 1, 4294967295, 4294967295, 1, 125, 8, 2969, 1, 4294967295, 4294967295, 1, 126, 8, 2970, 1, 4294967295, 4294967295, 3, 126, 8, 2971, 2, 2180, 4294967295, 8, 126, 8, 2973, 1, 4294967295, 4294967295, 1, 126, 8, 2974, 1, 4294967295, 4294967295, 1, 126, 8, 2975, 1, 4294967295, 4294967295, 1, 127, 8, 2976, 1, 4294967295, 4294967295, 1, 127, 8, 2977, 1, 4294967295, 4294967295, 3, 127, 8, 2978, 2, 2186, 4294967295, 8, 127, 8, 2980, 1, 4294967295, 4294967295, 1, 128, 8, 2981, 1, 4294967295, 4294967295, 1, 128, 32, 2982, 1, 4294967295, 4294967295, 1, 128, 8, 2983, 1, 4294967295, 4294967295, 1, 129, 32, 2984, 1, 4294967295, 4294967295, 1, 129, 8, 2985, 1, 4294967295, 4294967295, 1, 129, 32, 2986, 1, 4294967295, 4294967295, 1, 129, 8, 2987, 1, 4294967295, 4294967295, 5, 129, 8, 2988, 1, 2195, 4294967295, 8, 129, 8, 2989, 1, 4294967295, 4294967295, 10, 129, 8, 2990, 2, 4294967295, 4294967295, 12, 129, 8, 2992, 1, 4294967295, 2198, 9, 129, 8, 2993, 1, 4294967295, 4294967295, 1, 129, 32, 2994, 1, 4294967295, 4294967295, 3, 129, 8, 2995, 2, 2201, 4294967295, 8, 129, 8, 2997, 1, 4294967295, 4294967295, 3, 129, 8, 2998, 2, 2203, 4294967295, 8, 129, 8, 3000, 1, 4294967295, 4294967295, 1, 129, 32, 3001, 1, 4294967295, 4294967295, 1, 129, 8, 3002, 1, 4294967295, 4294967295, 1, 130, 32, 3003, 1, 4294967295, 4294967295, 1, 130, 8, 3004, 1, 4294967295, 4294967295, 1, 130, 32, 3005, 1, 4294967295, 4294967295, 1, 130, 8, 3006, 1, 4294967295, 4294967295, 1, 130, 32, 3007, 1, 4294967295, 4294967295, 1, 130, 8, 3008, 1, 4294967295, 4294967295, 1, 130, 32, 3009, 1, 4294967295, 4294967295, 1, 130, 8, 3010, 1, 4294967295, 4294967295, 1, 130, 32, 3011, 1, 4294967295, 4294967295, 1, 130, 8, 3012, 1, 4294967295, 4294967295, 1, 130, 32, 3013, 1, 4294967295, 4294967295, 1, 130, 8, 3014, 1, 4294967295, 4294967295, 3, 130, 8, 3015, 6, 2219, 4294967295, 8, 130, 8, 3021, 1, 4294967295, 4294967295, 1, 131, 32, 3022, 1, 4294967295, 4294967295, 1, 131, 8, 3023, 1, 4294967295, 4294967295, 3, 131, 8, 3024, 2, 2223, 4294967295, 8, 131, 8, 3026, 1, 4294967295, 4294967295, 1, 132, 8, 3027, 1, 4294967295, 4294967295, 1, 132, 8, 3028, 1, 4294967295, 4294967295, 1, 133, 32, 3029, 1, 4294967295, 4294967295, 1, 133, 8, 3030, 1, 4294967295, 4294967295, 1, 133, 8, 3031, 1, 4294967295, 4294967295, 1, 134, 32, 3032, 1, 4294967295, 4294967295, 1, 134, 8, 3033, 1, 4294967295, 4294967295, 1, 134, 8, 3034, 1, 4294967295, 4294967295, 1, 135, 32, 3035, 1, 4294967295, 4294967295, 1, 135, 8, 3036, 1, 4294967295, 4294967295, 1, 135, 8, 3037, 1, 4294967295, 4294967295, 1, 136, 32, 3038, 1, 4294967295, 4294967295, 1, 136, 8, 3039, 1, 4294967295, 4294967295, 1, 136, 32, 3040, 1, 4294967295, 4294967295, 1, 136, 8, 3041, 1, 4294967295, 4294967295, 1, 137, 32, 3042, 1, 4294967295, 4294967295, 1, 137, 32, 3043, 1, 4294967295, 4294967295, 1, 137, 8, 3044, 1, 4294967295, 4294967295, 1, 138, 8, 3045, 1, 4294967295, 4294967295, 5, 138, 8, 3046, 1, 2244, 4294967295, 8, 138, 8, 3047, 1, 4294967295, 4294967295, 10, 138, 8, 3048, 2, 4294967295, 4294967295, 12, 138, 8, 3050, 1, 4294967295, 2247, 9, 138, 8, 3051, 1, 4294967295, 4294967295, 1, 138, 32, 3052, 1, 4294967295, 4294967295, 1, 138, 8, 3053, 1, 4294967295, 4294967295, 3, 138, 8, 3054, 2, 2251, 4294967295, 8, 138, 8, 3056, 1, 4294967295, 4294967295, 1, 138, 32, 3057, 1, 4294967295, 4294967295, 1, 138, 8, 3058, 1, 4294967295, 4294967295, 1, 139, 8, 3059, 1, 4294967295, 4294967295, 5, 139, 8, 3060, 1, 2256, 4294967295, 8, 139, 8, 3061, 1, 4294967295, 4294967295, 10, 139, 8, 3062, 2, 4294967295, 4294967295, 12, 139, 8, 3064, 1, 4294967295, 2259, 9, 139, 8, 3065, 1, 4294967295, 4294967295, 1, 139, 32, 3066, 1, 4294967295, 4294967295, 1, 139, 8, 3067, 1, 4294967295, 4294967295, 1, 139, 8, 3068, 1, 4294967295, 4294967295, 5, 139, 8, 3069, 1, 2264, 4294967295, 8, 139, 8, 3070, 1, 4294967295, 4294967295, 10, 139, 8, 3071, 2, 4294967295, 4294967295, 12, 139, 8, 3073, 1, 4294967295, 2267, 9, 139, 8, 3074, 1, 4294967295, 4294967295, 1, 139, 8, 3075, 1, 4294967295, 4294967295, 3, 139, 8, 3076, 2, 2270, 4294967295, 8, 139, 8, 3078, 1, 4294967295, 4294967295, 1, 140, 32, 3079, 1, 4294967295, 4294967295, 1, 140, 8, 3080, 1, 4294967295, 4294967295, 3, 140, 8, 3081, 2, 2274, 4294967295, 8, 140, 8, 3083, 1, 4294967295, 4294967295, 1, 140, 8, 3084, 1, 4294967295, 4294967295, 3, 140, 8, 3085, 2, 2277, 4294967295, 8, 140, 8, 3087, 1, 4294967295, 4294967295, 1, 140, 8, 3088, 1, 4294967295, 4294967295, 1, 140, 8, 3089, 1, 4294967295, 4294967295, 1, 141, 32, 3090, 1, 4294967295, 4294967295, 1, 141, 8, 3091, 1, 4294967295, 4294967295, 1, 141, 8, 3092, 1, 4294967295, 4294967295, 3, 141, 8, 3093, 2, 2284, 4294967295, 8, 141, 8, 3095, 1, 4294967295, 4294967295, 1, 141, 32, 3096, 1, 4294967295, 4294967295, 1, 141, 8, 3097, 1, 4294967295, 4294967295, 1, 142, 32, 3098, 1, 4294967295, 4294967295, 1, 142, 32, 3099, 1, 4294967295, 4294967295, 1, 142, 8, 3100, 1, 4294967295, 4294967295, 1, 142, 32, 3101, 1, 4294967295, 4294967295, 1, 142, 8, 3102, 1, 4294967295, 4294967295, 1, 143, 32, 3103, 1, 4294967295, 4294967295, 1, 143, 8, 3104, 1, 4294967295, 4294967295, 1, 143, 8, 3105, 1, 4294967295, 4294967295, 1, 144, 8, 3106, 1, 4294967295, 4294967295, 5, 144, 8, 3107, 1, 2297, 4294967295, 8, 144, 8, 3108, 1, 4294967295, 4294967295, 10, 144, 8, 3109, 2, 4294967295, 4294967295, 12, 144, 8, 3111, 1, 4294967295, 2300, 9, 144, 8, 3112, 1, 4294967295, 4294967295, 1, 144, 32, 3113, 1, 4294967295, 4294967295, 1, 144, 8, 3114, 1, 4294967295, 4294967295, 1, 144, 8, 3115, 1, 4294967295, 4294967295, 1, 145, 8, 3116, 1, 4294967295, 4294967295, 5, 145, 8, 3117, 1, 2306, 4294967295, 8, 145, 8, 3118, 1, 4294967295, 4294967295, 10, 145, 8, 3119, 2, 4294967295, 4294967295, 12, 145, 8, 3121, 1, 4294967295, 2309, 9, 145, 8, 3122, 1, 4294967295, 4294967295, 1, 145, 32, 3123, 1, 4294967295, 4294967295, 3, 145, 8, 3124, 2, 2312, 4294967295, 8, 145, 8, 3126, 1, 4294967295, 4294967295, 1, 145, 32, 3127, 1, 4294967295, 4294967295, 1, 145, 32, 3128, 1, 4294967295, 4294967295, 1, 145, 8, 3129, 1, 4294967295, 4294967295, 1, 145, 8, 3130, 1, 4294967295, 4294967295, 3, 145, 8, 3131, 2, 2318, 4294967295, 8, 145, 8, 3133, 1, 4294967295, 4294967295, 1, 145, 32, 3134, 1, 4294967295, 4294967295, 1, 145, 8, 3135, 1, 4294967295, 4294967295, 1, 145, 8, 3136, 1, 4294967295, 4294967295, 1, 146, 8, 3137, 1, 4294967295, 4294967295, 5, 146, 8, 3138, 1, 2324, 4294967295, 8, 146, 8, 3139, 1, 4294967295, 4294967295, 10, 146, 8, 3140, 2, 4294967295, 4294967295, 12, 146, 8, 3142, 1, 4294967295, 2327, 9, 146, 8, 3143, 1, 4294967295, 4294967295, 1, 146, 32, 3144, 1, 4294967295, 4294967295, 1, 146, 32, 3145, 1, 4294967295, 4294967295, 1, 146, 8, 3146, 1, 4294967295, 4294967295, 1, 146, 32, 3147, 1, 4294967295, 4294967295, 1, 146, 8, 3148, 1, 4294967295, 4294967295, 1, 146, 8, 3149, 1, 4294967295, 4294967295, 1, 147, 8, 3150, 1, 4294967295, 4294967295, 5, 147, 8, 3151, 1, 2336, 4294967295, 8, 147, 8, 3152, 1, 4294967295, 4294967295, 10, 147, 8, 3153, 2, 4294967295, 4294967295, 12, 147, 8, 3155, 1, 4294967295, 2339, 9, 147, 8, 3156, 1, 4294967295, 4294967295, 1, 147, 32, 3157, 1, 4294967295, 4294967295, 1, 147, 32, 3158, 1, 4294967295, 4294967295, 1, 147, 8, 3159, 1, 4294967295, 4294967295, 3, 147, 8, 3160, 2, 2344, 4294967295, 8, 147, 8, 3162, 1, 4294967295, 4294967295, 1, 147, 32, 3163, 1, 4294967295, 4294967295, 1, 147, 8, 3164, 1, 4294967295, 4294967295, 1, 148, 72, 3165, 1, 4294967295, 4294967295, 1, 148, 8, 3166, 1, 4294967295, 4294967295, 1, 148, 8, 3167, 1, 4294967295, 4294967295, 1, 148, 8, 3168, 1, 4294967295, 4294967295, 1, 148, 8, 3169, 1, 4294967295, 4294967295, 1, 148, 8, 3170, 1, 4294967295, 4294967295, 1, 148, 8, 3171, 1, 4294967295, 4294967295, 1, 148, 8, 3172, 1, 4294967295, 4294967295, 1, 148, 8, 3173, 1, 4294967295, 4294967295, 1, 148, 8, 3174, 1, 4294967295, 4294967295, 1, 148, 8, 3175, 1, 4294967295, 4294967295, 1, 148, 8, 3176, 1, 4294967295, 4294967295, 1, 148, 8, 3177, 1, 4294967295, 4294967295, 1, 148, 8, 3178, 1, 4294967295, 4294967295, 1, 148, 8, 3179, 1, 4294967295, 4294967295, 1, 148, 8, 3180, 1, 4294967295, 4294967295, 1, 148, 8, 3181, 1, 4294967295, 4294967295, 1, 148, 8, 3182, 1, 4294967295, 4294967295, 1, 148, 8, 3183, 1, 4294967295, 4294967295, 1, 148, 8, 3184, 1, 4294967295, 4294967295, 1, 148, 8, 3185, 1, 4294967295, 4294967295, 1, 148, 8, 3186, 1, 4294967295, 4294967295, 1, 148, 8, 3187, 1, 4294967295, 4294967295, 1, 148, 8, 3188, 1, 4294967295, 4294967295, 1, 148, 32, 3189, 1, 4294967295, 4294967295, 1, 148, 8, 3190, 1, 4294967295, 4294967295, 3, 148, 8, 3191, 2, 2374, 4294967295, 8, 148, 8, 3193, 1, 4294967295, 4294967295, 1, 148, 8, 3194, 1, 4294967295, 4294967295, 1, 148, 8, 3195, 1, 4294967295, 4294967295, 1, 148, 8, 3196, 1, 4294967295, 4294967295, 1, 148, 8, 3197, 1, 4294967295, 4294967295, 1, 148, 8, 3198, 1, 4294967295, 4294967295, 1, 148, 8, 3199, 1, 4294967295, 4294967295, 1, 148, 8, 3200, 1, 4294967295, 4294967295, 1, 148, 8, 3201, 1, 4294967295, 4294967295, 1, 148, 8, 3202, 1, 4294967295, 4294967295, 1, 148, 8, 3203, 1, 4294967295, 4294967295, 1, 148, 8, 3204, 1, 4294967295, 4294967295, 3, 148, 8, 3205, 35, 2387, 4294967295, 8, 148, 8, 3240, 1, 4294967295, 4294967295, 1, 148, 72, 3241, 1, 4294967295, 4294967295, 1, 148, 32, 3242, 1, 4294967295, 4294967295, 1, 148, 32, 3243, 1, 4294967295, 4294967295, 1, 148, 32, 3244, 1, 4294967295, 4294967295, 1, 148, 32, 3245, 1, 4294967295, 4294967295, 1, 148, 32, 3246, 1, 4294967295, 4294967295, 1, 148, 32, 3247, 1, 4294967295, 4294967295, 1, 148, 32, 3248, 1, 4294967295, 4294967295, 1, 148, 32, 3249, 1, 4294967295, 4294967295, 1, 148, 32, 3250, 1, 4294967295, 4294967295, 1, 148, 32, 3251, 1, 4294967295, 4294967295, 1, 148, 8, 3252, 1, 4294967295, 4294967295, 1, 148, 8, 3253, 1, 4294967295, 4294967295, 1, 148, 32, 3254, 1, 4294967295, 4294967295, 3, 148, 8, 3255, 13, 2403, 4294967295, 8, 148, 8, 3268, 1, 4294967295, 4294967295, 1, 148, 8, 3269, 1, 4294967295, 4294967295, 1, 148, 72, 3270, 1, 4294967295, 4294967295, 1, 148, 32, 3271, 1, 4294967295, 4294967295, 1, 148, 32, 3272, 1, 4294967295, 4294967295, 1, 148, 32, 3273, 1, 4294967295, 4294967295, 1, 148, 32, 3274, 1, 4294967295, 4294967295, 1, 148, 32, 3275, 1, 4294967295, 4294967295, 1, 148, 32, 3276, 1, 4294967295, 4294967295, 1, 148, 8, 3277, 1, 4294967295, 4294967295, 1, 148, 8, 3278, 1, 4294967295, 4294967295, 1, 148, 32, 3279, 1, 4294967295, 4294967295, 1, 148, 32, 3280, 1, 4294967295, 4294967295, 1, 148, 32, 3281, 1, 4294967295, 4294967295, 1, 148, 32, 3282, 1, 4294967295, 4294967295, 1, 148, 32, 3283, 1, 4294967295, 4294967295, 1, 148, 32, 3284, 1, 4294967295, 4294967295, 1, 148, 32, 3285, 1, 4294967295, 4294967295, 1, 148, 32, 3286, 1, 4294967295, 4294967295, 1, 148, 32, 3287, 1, 4294967295, 4294967295, 1, 148, 32, 3288, 1, 4294967295, 4294967295, 1, 148, 32, 3289, 1, 4294967295, 4294967295, 1, 148, 32, 3290, 1, 4294967295, 4294967295, 1, 148, 32, 3291, 1, 4294967295, 4294967295, 1, 148, 32, 3292, 1, 4294967295, 4294967295, 3, 148, 8, 3293, 22, 2429, 4294967295, 8, 148, 8, 3315, 1, 4294967295, 4294967295, 1, 148, 8, 3316, 1, 4294967295, 4294967295, 1, 148, 72, 3317, 1, 4294967295, 4294967295, 1, 148, 32, 3318, 1, 4294967295, 4294967295, 1, 148, 8, 3319, 1, 4294967295, 4294967295, 1, 148, 72, 3320, 1, 4294967295, 4294967295, 1, 148, 32, 3321, 1, 4294967295, 4294967295, 1, 148, 8, 3322, 1, 4294967295, 4294967295, 1, 148, 32, 3323, 1, 4294967295, 4294967295, 1, 148, 8, 3324, 1, 4294967295, 4294967295, 1, 148, 8, 3325, 1, 4294967295, 4294967295, 1, 148, 72, 3326, 1, 4294967295, 4294967295, 1, 148, 8, 3327, 1, 4294967295, 4294967295, 1, 148, 72, 3328, 1, 4294967295, 4294967295, 1, 148, 8, 3329, 1, 4294967295, 4294967295, 1, 148, 72, 3330, 1, 4294967295, 4294967295, 1, 148, 32, 3331, 1, 4294967295, 4294967295, 1, 148, 8, 3332, 1, 4294967295, 4294967295, 1, 148, 72, 3333, 1, 4294967295, 4294967295, 1, 148, 32, 3334, 1, 4294967295, 4294967295, 1, 148, 8, 3335, 1, 4294967295, 4294967295, 1, 148, 72, 3336, 1, 4294967295, 4294967295, 1, 148, 32, 3337, 1, 4294967295, 4294967295, 1, 148, 72, 3338, 1, 4294967295, 4294967295, 1, 148, 32, 3339, 1, 4294967295, 4294967295, 1, 148, 8, 3340, 1, 4294967295, 4294967295, 3, 148, 8, 3341, 2, 2456, 4294967295, 8, 148, 8, 3343, 1, 4294967295, 4294967295, 1, 148, 72, 3344, 1, 4294967295, 4294967295, 1, 148, 32, 3345, 1, 4294967295, 4294967295, 1, 148, 32, 3346, 1, 4294967295, 4294967295, 1, 148, 8, 3347, 1, 4294967295, 4294967295, 1, 148, 32, 3348, 1, 4294967295, 4294967295, 1, 148, 8, 3349, 1, 4294967295, 4294967295, 5, 148, 8, 3350, 1, 2464, 4294967295, 8, 148, 8, 3351, 1, 4294967295, 4294967295, 10, 148, 8, 3352, 2, 4294967295, 4294967295, 12, 148, 8, 3354, 1, 4294967295, 2467, 9, 148, 8, 3355, 1, 4294967295, 4294967295, 1, 148, 32, 3356, 1, 4294967295, 4294967295, 3, 148, 8, 3357, 2, 2470, 4294967295, 8, 148, 8, 3359, 1, 4294967295, 4294967295, 3, 148, 8, 3360, 2, 2472, 4294967295, 8, 148, 8, 3362, 1, 4294967295, 4294967295, 1, 148, 32, 3363, 1, 4294967295, 4294967295, 1, 148, 72, 3364, 1, 4294967295, 4294967295, 1, 148, 32, 3365, 1, 4294967295, 4294967295, 1, 148, 8, 3366, 1, 4294967295, 4294967295, 5, 148, 8, 3367, 12, 2478, 4294967295, 8, 148, 8, 3379, 1, 4294967295, 4294967295, 10, 148, 10, 3380, 2, 4294967295, 4294967295, 12, 148, 8, 3382, 1, 4294967295, 2481, 9, 148, 8, 3383, 1, 4294967295, 4294967295, 1, 149, 8, 3384, 1, 4294967295, 4294967295, 1, 149, 8, 3385, 1, 4294967295, 4294967295, 3, 149, 8, 3386, 2, 2485, 4294967295, 8, 149, 8, 3388, 1, 4294967295, 4294967295, 1, 150, 8, 3389, 1, 4294967295, 4294967295, 5, 150, 8, 3390, 1, 2488, 4294967295, 8, 150, 8, 3391, 1, 4294967295, 4294967295, 10, 150, 8, 3392, 2, 4294967295, 4294967295, 12, 150, 8, 3394, 1, 4294967295, 2491, 9, 150, 8, 3395, 1, 4294967295, 4294967295, 1, 150, 32, 3396, 1, 4294967295, 4294967295, 1, 150, 8, 3397, 1, 4294967295, 4294967295, 3, 150, 8, 3398, 2, 2495, 4294967295, 8, 150, 8, 3400, 1, 4294967295, 4294967295, 1, 150, 8, 3401, 1, 4294967295, 4294967295, 1, 150, 8, 3402, 1, 4294967295, 4294967295, 3, 150, 8, 3403, 2, 2499, 4294967295, 8, 150, 8, 3405, 1, 4294967295, 4294967295, 1, 151, 8, 3406, 1, 4294967295, 4294967295, 1, 151, 8, 3407, 1, 4294967295, 4294967295, 3, 151, 8, 3408, 2, 2503, 4294967295, 8, 151, 8, 3410, 1, 4294967295, 4294967295, 1, 152, 8, 3411, 1, 4294967295, 4294967295, 5, 152, 8, 3412, 1, 2506, 4294967295, 8, 152, 8, 3413, 1, 4294967295, 4294967295, 10, 152, 8, 3414, 2, 4294967295, 4294967295, 12, 152, 8, 3416, 1, 4294967295, 2509, 9, 152, 8, 3417, 1, 4294967295, 4294967295, 1, 152, 8, 3418, 1, 4294967295, 4294967295, 5, 152, 8, 3419, 1, 2512, 4294967295, 8, 152, 8, 3420, 1, 4294967295, 4294967295, 10, 152, 8, 3421, 2, 4294967295, 4294967295, 12, 152, 8, 3423, 1, 4294967295, 2515, 9, 152, 8, 3424, 1, 4294967295, 4294967295, 1, 152, 8, 3425, 1, 4294967295, 4294967295, 3, 152, 8, 3426, 2, 2518, 4294967295, 8, 152, 8, 3428, 1, 4294967295, 4294967295, 1, 152, 8, 3429, 1, 4294967295, 4294967295, 1, 152, 32, 3430, 1, 4294967295, 4294967295, 1, 152, 8, 3431, 1, 4294967295, 4294967295, 1, 152, 8, 3432, 1, 4294967295, 4294967295, 3, 152, 8, 3433, 2, 2524, 4294967295, 8, 152, 8, 3435, 1, 4294967295, 4294967295, 1, 153, 8, 3436, 1, 4294967295, 4294967295, 5, 153, 8, 3437, 1, 2527, 4294967295, 8, 153, 8, 3438, 1, 4294967295, 4294967295, 10, 153, 8, 3439, 2, 4294967295, 4294967295, 12, 153, 8, 3441, 1, 4294967295, 2530, 9, 153, 8, 3442, 1, 4294967295, 4294967295, 1, 153, 8, 3443, 1, 4294967295, 4294967295, 5, 153, 8, 3444, 1, 2533, 4294967295, 8, 153, 8, 3445, 1, 4294967295, 4294967295, 10, 153, 8, 3446, 2, 4294967295, 4294967295, 12, 153, 8, 3448, 1, 4294967295, 2536, 9, 153, 8, 3449, 1, 4294967295, 4294967295, 1, 153, 8, 3450, 1, 4294967295, 4294967295, 1, 153, 32, 3451, 1, 4294967295, 4294967295, 1, 153, 8, 3452, 1, 4294967295, 4294967295, 1, 153, 8, 3453, 1, 4294967295, 4294967295, 3, 153, 8, 3454, 2, 2542, 4294967295, 8, 153, 8, 3456, 1, 4294967295, 4294967295, 1, 154, 32, 3457, 1, 4294967295, 4294967295, 1, 154, 32, 3458, 1, 4294967295, 4294967295, 1, 154, 8, 3459, 1, 4294967295, 4294967295, 1, 154, 32, 3460, 1, 4294967295, 4294967295, 1, 154, 8, 3461, 1, 4294967295, 4294967295, 5, 154, 8, 3462, 1, 2549, 4294967295, 8, 154, 8, 3463, 1, 4294967295, 4294967295, 10, 154, 8, 3464, 2, 4294967295, 4294967295, 12, 154, 8, 3466, 1, 4294967295, 2552, 9, 154, 8, 3467, 1, 4294967295, 4294967295, 1, 154, 32, 3468, 1, 4294967295, 4294967295, 3, 154, 8, 3469, 2, 2555, 4294967295, 8, 154, 8, 3471, 1, 4294967295, 4294967295, 3, 154, 8, 3472, 2, 2557, 4294967295, 8, 154, 8, 3474, 1, 4294967295, 4294967295, 1, 154, 32, 3475, 1, 4294967295, 4294967295, 1, 154, 8, 3476, 1, 4294967295, 4294967295, 1, 155, 8, 3477, 1, 4294967295, 4294967295, 3, 155, 8, 3478, 2, 2562, 4294967295, 8, 155, 8, 3480, 1, 4294967295, 4294967295, 1, 155, 8, 3481, 1, 4294967295, 4294967295, 1, 155, 8, 3482, 1, 4294967295, 4294967295, 1, 156, 32, 3483, 1, 4294967295, 4294967295, 1, 156, 8, 3484, 1, 4294967295, 4294967295, 1, 156, 8, 3485, 1, 4294967295, 4294967295, 3, 156, 8, 3486, 2, 2569, 4294967295, 8, 156, 8, 3488, 1, 4294967295, 4294967295, 1, 157, 32, 3489, 1, 4294967295, 4294967295, 1, 157, 8, 3490, 1, 4294967295, 4294967295, 1, 157, 32, 3491, 1, 4294967295, 4294967295, 1, 157, 8, 3492, 1, 4294967295, 4294967295, 5, 157, 8, 3493, 1, 2575, 4294967295, 8, 157, 8, 3494, 1, 4294967295, 4294967295, 10, 157, 8, 3495, 2, 4294967295, 4294967295, 12, 157, 8, 3497, 1, 4294967295, 2578, 9, 157, 8, 3498, 1, 4294967295, 4294967295, 1, 157, 32, 3499, 1, 4294967295, 4294967295, 3, 157, 8, 3500, 2, 2581, 4294967295, 8, 157, 8, 3502, 1, 4294967295, 4294967295, 3, 157, 8, 3503, 2, 2583, 4294967295, 8, 157, 8, 3505, 1, 4294967295, 4294967295, 1, 157, 32, 3506, 1, 4294967295, 4294967295, 1, 157, 8, 3507, 1, 4294967295, 4294967295, 1, 158, 32, 3508, 1, 4294967295, 4294967295, 1, 158, 8, 3509, 1, 4294967295, 4294967295, 1, 158, 8, 3510, 1, 4294967295, 4294967295, 1, 159, 8, 3511, 1, 4294967295, 4294967295, 1, 159, 8, 3512, 1, 4294967295, 4294967295, 3, 159, 8, 3513, 2, 2592, 4294967295, 8, 159, 8, 3515, 1, 4294967295, 4294967295, 1, 160, 32, 3516, 1, 4294967295, 4294967295, 1, 160, 8, 3517, 1, 4294967295, 4294967295, 1, 160, 8, 3518, 1, 4294967295, 4294967295, 3, 160, 8, 3519, 2, 2597, 4294967295, 8, 160, 8, 3521, 1, 4294967295, 4294967295, 1, 161, 32, 3522, 1, 4294967295, 4294967295, 1, 161, 8, 3523, 1, 4294967295, 4294967295, 1, 161, 8, 3524, 1, 4294967295, 4294967295, 3, 161, 8, 3525, 2, 2602, 4294967295, 8, 161, 8, 3527, 1, 4294967295, 4294967295, 1, 161, 8, 3528, 1, 4294967295, 4294967295, 3, 161, 8, 3529, 2, 2605, 4294967295, 8, 161, 8, 3531, 1, 4294967295, 4294967295, 1, 162, 32, 3532, 1, 4294967295, 4294967295, 1, 162, 8, 3533, 1, 4294967295, 4294967295, 1, 162, 32, 3534, 1, 4294967295, 4294967295, 1, 162, 8, 3535, 1, 4294967295, 4294967295, 1, 162, 8, 3536, 1, 4294967295, 4294967295, 1, 163, 32, 3537, 1, 4294967295, 4294967295, 1, 163, 32, 3538, 1, 4294967295, 4294967295, 1, 163, 8, 3539, 1, 4294967295, 4294967295, 1, 163, 32, 3540, 1, 4294967295, 4294967295, 1, 163, 8, 3541, 1, 4294967295, 4294967295, 1, 163, 32, 3542, 1, 4294967295, 4294967295, 1, 163, 32, 3543, 1, 4294967295, 4294967295, 1, 163, 8, 3544, 1, 4294967295, 4294967295, 1, 163, 32, 3545, 1, 4294967295, 4294967295, 1, 163, 8, 3546, 1, 4294967295, 4294967295, 3, 163, 8, 3547, 2, 2622, 4294967295, 8, 163, 8, 3549, 1, 4294967295, 4294967295, 1, 164, 32, 3550, 1, 4294967295, 4294967295, 1, 164, 8, 3551, 1, 4294967295, 4294967295, 1, 164, 32, 3552, 1, 4294967295, 4294967295, 1, 164, 8, 3553, 1, 4294967295, 4294967295, 5, 164, 8, 3554, 1, 2628, 4294967295, 8, 164, 8, 3555, 1, 4294967295, 4294967295, 10, 164, 8, 3556, 2, 4294967295, 4294967295, 12, 164, 8, 3558, 1, 4294967295, 2631, 9, 164, 8, 3559, 1, 4294967295, 4294967295, 1, 164, 32, 3560, 1, 4294967295, 4294967295, 3, 164, 8, 3561, 2, 2634, 4294967295, 8, 164, 8, 3563, 1, 4294967295, 4294967295, 3, 164, 8, 3564, 2, 2636, 4294967295, 8, 164, 8, 3566, 1, 4294967295, 4294967295, 1, 164, 32, 3567, 1, 4294967295, 4294967295, 1, 164, 8, 3568, 1, 4294967295, 4294967295, 1, 165, 8, 3569, 1, 4294967295, 4294967295, 1, 165, 8, 3570, 1, 4294967295, 4294967295, 1, 165, 8, 3571, 1, 4294967295, 4294967295, 3, 165, 8, 3572, 3, 2643, 4294967295, 8, 165, 8, 3575, 1, 4294967295, 4294967295, 1, 166, 8, 3576, 1, 4294967295, 4294967295, 1, 166, 8, 3577, 1, 4294967295, 4294967295, 1, 167, 32, 3578, 1, 4294967295, 4294967295, 1, 167, 8, 3579, 1, 4294967295, 4294967295, 1, 167, 8, 3580, 1, 4294967295, 4294967295, 1, 168, 32, 3581, 1, 4294967295, 4294967295, 1, 168, 8, 3582, 1, 4294967295, 4294967295, 1, 168, 8, 3583, 1, 4294967295, 4294967295, 1, 169, 8, 3584, 1, 4294967295, 4294967295, 1, 169, 8, 3585, 1, 4294967295, 4294967295, 1, 169, 8, 3586, 1, 4294967295, 4294967295, 1, 170, 32, 3587, 1, 4294967295, 4294967295, 1, 170, 32, 3588, 1, 4294967295, 4294967295, 1, 170, 8, 3589, 1, 4294967295, 4294967295, 1, 170, 32, 3590, 1, 4294967295, 4294967295, 1, 170, 8, 3591, 1, 4294967295, 4294967295, 1, 171, 8, 3592, 1, 4294967295, 4294967295, 1, 171, 8, 3593, 1, 4294967295, 4294967295, 1, 172, 32, 3594, 1, 4294967295, 4294967295, 1, 172, 8, 3595, 1, 4294967295, 4294967295, 1, 173, 32, 3596, 1, 4294967295, 4294967295, 1, 173, 32, 3597, 1, 4294967295, 4294967295, 1, 173, 32, 3598, 1, 4294967295, 4294967295, 5, 173, 8, 3599, 1, 2668, 4294967295, 8, 173, 8, 3600, 1, 4294967295, 4294967295, 10, 173, 8, 3601, 2, 4294967295, 4294967295, 12, 173, 8, 3603, 1, 4294967295, 2671, 9, 173, 8, 3604, 1, 4294967295, 4294967295, 1, 173, 32, 3605, 1, 4294967295, 4294967295, 1, 173, 8, 3606, 1, 4294967295, 4294967295, 1, 173, 8, 3607, 1, 4294967295, 4294967295, 1, 174, 8, 3608, 1, 4294967295, 4294967295, 1, 174, 8, 3609, 1, 4294967295, 4294967295, 1, 175, 32, 3610, 1, 4294967295, 4294967295, 1, 175, 32, 3611, 1, 4294967295, 4294967295, 1, 175, 32, 3612, 1, 4294967295, 4294967295, 1, 175, 8, 3613, 1, 4294967295, 4294967295, 1, 175, 8, 3614, 1, 4294967295, 4294967295, 1, 176, 8, 3615, 1, 4294967295, 4294967295, 1, 176, 8, 3616, 1, 4294967295, 4294967295, 3, 176, 8, 3617, 2, 2685, 4294967295, 8, 176, 8, 3619, 1, 4294967295, 4294967295, 1, 177, 32, 3620, 1, 4294967295, 4294967295, 1, 177, 8, 3621, 1, 4294967295, 4294967295, 1, 178, 32, 3622, 1, 4294967295, 4294967295, 1, 178, 8, 3623, 1, 4294967295, 4294967295, 1, 179, 32, 3624, 1, 4294967295, 4294967295, 1, 179, 8, 3625, 1, 4294967295, 4294967295, 5, 179, 8, 3626, 1, 2693, 4294967295, 8, 179, 8, 3627, 1, 4294967295, 4294967295, 10, 179, 8, 3628, 2, 4294967295, 4294967295, 12, 179, 8, 3630, 1, 4294967295, 2696, 9, 179, 8, 3631, 1, 4294967295, 4294967295, 1, 179, 32, 3632, 1, 4294967295, 4294967295, 1, 179, 32, 3633, 1, 4294967295, 4294967295, 1, 179, 8, 3634, 1, 4294967295, 4294967295, 5, 179, 8, 3635, 1, 2701, 4294967295, 8, 179, 8, 3636, 1, 4294967295, 4294967295, 10, 179, 8, 3637, 2, 4294967295, 4294967295, 12, 179, 8, 3639, 1, 4294967295, 2704, 9, 179, 8, 3640, 1, 4294967295, 4294967295, 1, 179, 32, 3641, 1, 4294967295, 4294967295, 1, 179, 8, 3642, 1, 4294967295, 4294967295, 1, 179, 8, 3643, 1, 4294967295, 4294967295, 5, 179, 8, 3644, 1, 2709, 4294967295, 8, 179, 8, 3645, 1, 4294967295, 4294967295, 10, 179, 8, 3646, 2, 4294967295, 4294967295, 12, 179, 8, 3648, 1, 4294967295, 2712, 9, 179, 8, 3649, 1, 4294967295, 4294967295, 1, 179, 8, 3650, 1, 4294967295, 4294967295, 1, 179, 8, 3651, 1, 4294967295, 4294967295, 1, 179, 8, 3652, 1, 4294967295, 4294967295, 1, 179, 8, 3653, 1, 4294967295, 4294967295, 5, 179, 8, 3654, 1, 2718, 4294967295, 8, 179, 8, 3655, 1, 4294967295, 4294967295, 10, 179, 8, 3656, 2, 4294967295, 4294967295, 12, 179, 8, 3658, 1, 4294967295, 2721, 9, 179, 8, 3659, 1, 4294967295, 4294967295, 1, 179, 8, 3660, 1, 4294967295, 4294967295, 1, 179, 8, 3661, 1, 4294967295, 4294967295, 3, 179, 8, 3662, 4, 2725, 4294967295, 8, 179, 8, 3666, 1, 4294967295, 4294967295, 1, 180, 8, 3667, 1, 4294967295, 4294967295, 1, 180, 8, 3668, 1, 4294967295, 4294967295, 3, 180, 8, 3669, 2, 2729, 4294967295, 8, 180, 8, 3671, 1, 4294967295, 4294967295, 1, 181, 8, 3672, 1, 4294967295, 4294967295, 1, 181, 8, 3673, 1, 4294967295, 4294967295, 1, 182, 32, 3674, 1, 4294967295, 4294967295, 1, 182, 8, 3675, 1, 4294967295, 4294967295, 1, 182, 8, 3676, 1, 4294967295, 4294967295, 3, 182, 8, 3677, 2, 2736, 4294967295, 8, 182, 8, 3679, 1, 4294967295, 4294967295, 1, 182, 8, 3680, 1, 4294967295, 4294967295, 3, 182, 8, 3681, 2, 2739, 4294967295, 8, 182, 8, 3683, 1, 4294967295, 4294967295, 1, 182, 32, 3684, 1, 4294967295, 4294967295, 1, 182, 8, 3685, 1, 4294967295, 4294967295, 1, 183, 32, 3686, 1, 4294967295, 4294967295, 1, 183, 8, 3687, 1, 4294967295, 4294967295, 1, 183, 8, 3688, 1, 4294967295, 4294967295, 1, 184, 32, 3689, 1, 4294967295, 4294967295, 1, 184, 8, 3690, 1, 4294967295, 4294967295, 1, 184, 8, 3691, 1, 4294967295, 4294967295, 1, 185, 32, 3692, 1, 4294967295, 4294967295, 1, 185, 8, 3693, 1, 4294967295, 4294967295, 1, 186, 32, 3694, 1, 4294967295, 4294967295, 1, 186, 32, 3695, 1, 4294967295, 4294967295, 5, 186, 8, 3696, 1, 2753, 4294967295, 8, 186, 8, 3697, 1, 4294967295, 4294967295, 10, 186, 8, 3698, 2, 4294967295, 4294967295, 12, 186, 8, 3700, 1, 4294967295, 2756, 9, 186, 8, 3701, 1, 4294967295, 4294967295, 1, 187, 32, 3702, 1, 4294967295, 4294967295, 1, 187, 8, 3703, 1, 4294967295, 4294967295, 1, 188, 32, 3704, 1, 4294967295, 4294967295, 1, 188, 32, 3705, 1, 4294967295, 4294967295, 1, 188, 32, 3706, 1, 4294967295, 4294967295, 1, 188, 32, 3707, 1, 4294967295, 4294967295, 1, 188, 32, 3708, 1, 4294967295, 4294967295, 1, 188, 8, 3709, 1, 4294967295, 4294967295, 1, 188, 8, 3710, 1, 4294967295, 4294967295, 1, 188, 8, 3711, 1, 4294967295, 4294967295, 1, 188, 8, 3712, 1, 4294967295, 4294967295, 1, 188, 8, 3713, 1, 4294967295, 4294967295, 1, 188, 8, 3714, 1, 4294967295, 4294967295, 1, 188, 8, 3715, 1, 4294967295, 4294967295, 1, 188, 8, 3716, 1, 4294967295, 4294967295, 3, 188, 8, 3717, 13, 2773, 4294967295, 8, 188, 8, 3730, 1, 4294967295, 4294967295, 1, 189, 8, 3731, 1, 4294967295, 4294967295, 1, 189, 32, 3732, 1, 4294967295, 4294967295, 1, 189, 8, 3733, 1, 4294967295, 4294967295, 1, 190, 8, 3734, 1, 4294967295, 4294967295, 1, 190, 32, 3735, 1, 4294967295, 4294967295, 1, 190, 8, 3736, 1, 4294967295, 4294967295, 1, 191, 8, 3737, 1, 4294967295, 4294967295, 1, 191, 32, 3738, 1, 4294967295, 4294967295, 1, 191, 8, 3739, 1, 4294967295, 4294967295, 1, 192, 32, 3740, 1, 4294967295, 4294967295, 1, 192, 32, 3741, 1, 4294967295, 4294967295, 1, 192, 8, 3742, 1, 4294967295, 4294967295, 1, 192, 32, 3743, 1, 4294967295, 4294967295, 1, 192, 8, 3744, 1, 4294967295, 4294967295, 1, 193, 32, 3745, 1, 4294967295, 4294967295, 1, 193, 8, 3746, 1, 4294967295, 4294967295, 1, 193, 8, 3747, 1, 4294967295, 4294967295, 1, 194, 32, 3748, 1, 4294967295, 4294967295, 1, 194, 8, 3749, 1, 4294967295, 4294967295, 1, 194, 32, 3750, 1, 4294967295, 4294967295, 1, 194, 8, 3751, 1, 4294967295, 4294967295, 1, 195, 32, 3752, 1, 4294967295, 4294967295, 1, 195, 8, 3753, 1, 4294967295, 4294967295, 1, 195, 32, 3754, 1, 4294967295, 4294967295, 1, 195, 8, 3755, 1, 4294967295, 4294967295, 1, 195, 32, 3756, 1, 4294967295, 4294967295, 1, 195, 8, 3757, 1, 4294967295, 4294967295, 1, 195, 32, 3758, 1, 4294967295, 4294967295, 1, 195, 8, 3759, 1, 4294967295, 4294967295, 1, 195, 32, 3760, 1, 4294967295, 4294967295, 1, 195, 8, 3761, 1, 4294967295, 4294967295, 1, 195, 32, 3762, 1, 4294967295, 4294967295, 1, 195, 8, 3763, 1, 4294967295, 4294967295, 1, 195, 32, 3764, 1, 4294967295, 4294967295, 1, 195, 8, 3765, 1, 4294967295, 4294967295, 1, 195, 32, 3766, 1, 4294967295, 4294967295, 1, 195, 8, 3767, 1, 4294967295, 4294967295, 1, 195, 32, 3768, 1, 4294967295, 4294967295, 1, 195, 8, 3769, 1, 4294967295, 4294967295, 3, 195, 8, 3770, 9, 2814, 4294967295, 8, 195, 8, 3779, 1, 4294967295, 4294967295, 1, 196, 8, 3780, 1, 4294967295, 4294967295, 1, 196, 8, 3781, 1, 4294967295, 4294967295, 1, 196, 8, 3782, 1, 4294967295, 4294967295, 1, 197, 32, 3783, 1, 4294967295, 4294967295, 1, 197, 8, 3784, 1, 4294967295, 4294967295, 3, 197, 8, 3785, 2, 2821, 4294967295, 8, 197, 8, 3787, 1, 4294967295, 4294967295, 1, 197, 8, 3788, 1, 4294967295, 4294967295, 1, 197, 32, 3789, 1, 4294967295, 4294967295, 1, 197, 8, 3790, 1, 4294967295, 4294967295, 1, 197, 8, 3791, 1, 4294967295, 4294967295, 1, 198, 8, 3792, 1, 4294967295, 4294967295, 5, 198, 8, 3793, 1, 2828, 4294967295, 8, 198, 8, 3794, 1, 4294967295, 4294967295, 10, 198, 8, 3795, 2, 4294967295, 4294967295, 12, 198, 8, 3797, 1, 4294967295, 2831, 9, 198, 8, 3798, 1, 4294967295, 4294967295, 1, 198, 8, 3799, 1, 4294967295, 4294967295, 1, 198, 8, 3800, 1, 4294967295, 4294967295, 3, 198, 8, 3801, 2, 2835, 4294967295, 8, 198, 8, 3803, 1, 4294967295, 4294967295, 1, 199, 8, 3804, 1, 4294967295, 4294967295, 1, 199, 8, 3805, 1, 4294967295, 4294967295, 1, 199, 8, 3806, 1, 4294967295, 4294967295, 1, 199, 8, 3807, 1, 4294967295, 4294967295, 1, 199, 8, 3808, 1, 4294967295, 4294967295, 3, 199, 8, 3809, 5, 2842, 4294967295, 8, 199, 8, 3814, 1, 4294967295, 4294967295, 1, 200, 32, 3815, 1, 4294967295, 4294967295, 1, 200, 8, 3816, 1, 4294967295, 4294967295, 3, 200, 8, 3817, 2, 2846, 4294967295, 8, 200, 8, 3819, 1, 4294967295, 4294967295, 1, 200, 8, 3820, 1, 4294967295, 4294967295, 1, 200, 32, 3821, 1, 4294967295, 4294967295, 1, 200, 8, 3822, 1, 4294967295, 4294967295, 1, 200, 32, 3823, 1, 4294967295, 4294967295, 1, 200, 8, 3824, 1, 4294967295, 4294967295, 1, 200, 32, 3825, 1, 4294967295, 4294967295, 1, 200, 8, 3826, 1, 4294967295, 4294967295, 1, 200, 8, 3827, 1, 4294967295, 4294967295, 3, 200, 8, 3828, 2, 2856, 4294967295, 8, 200, 8, 3830, 1, 4294967295, 4294967295, 1, 201, 32, 3831, 1, 4294967295, 4294967295, 1, 201, 8, 3832, 1, 4294967295, 4294967295, 1, 201, 8, 3833, 1, 4294967295, 4294967295, 1, 202, 32, 3834, 1, 4294967295, 4294967295, 1, 202, 8, 3835, 1, 4294967295, 4294967295, 1, 202, 32, 3836, 1, 4294967295, 4294967295, 1, 202, 8, 3837, 1, 4294967295, 4294967295, 1, 202, 8, 3838, 1, 4294967295, 4294967295, 1, 203, 32, 3839, 1, 4294967295, 4294967295, 1, 203, 8, 3840, 1, 4294967295, 4294967295, 1, 203, 32, 3841, 1, 4294967295, 4294967295, 1, 203, 8, 3842, 1, 4294967295, 4294967295, 5, 203, 8, 3843, 1, 2870, 4294967295, 8, 203, 8, 3844, 1, 4294967295, 4294967295, 10, 203, 8, 3845, 2, 4294967295, 4294967295, 12, 203, 8, 3847, 1, 4294967295, 2873, 9, 203, 8, 3848, 1, 4294967295, 4294967295, 1, 204, 8, 3849, 1, 4294967295, 4294967295, 1, 204, 32, 3850, 1, 4294967295, 4294967295, 3, 204, 8, 3851, 2, 2877, 4294967295, 8, 204, 8, 3853, 1, 4294967295, 4294967295, 1, 205, 32, 3854, 1, 4294967295, 4294967295, 1, 205, 8, 3855, 1, 4294967295, 4294967295, 1, 205, 8, 3856, 1, 4294967295, 4294967295, 1, 206, 8, 3857, 1, 4294967295, 4294967295, 1, 206, 8, 3858, 1, 4294967295, 4294967295, 3, 206, 8, 3859, 2, 2884, 4294967295, 8, 206, 8, 3861, 1, 4294967295, 4294967295, 1, 207, 32, 3862, 1, 4294967295, 4294967295, 1, 207, 8, 3863, 1, 4294967295, 4294967295, 1, 207, 32, 3864, 1, 4294967295, 4294967295, 1, 207, 8, 3865, 1, 4294967295, 4294967295, 1, 207, 8, 3866, 1, 4294967295, 4294967295, 1, 208, 32, 3867, 1, 4294967295, 4294967295, 1, 208, 8, 3868, 1, 4294967295, 4294967295, 1, 208, 8, 3869, 1, 4294967295, 4294967295, 1, 209, 32, 3870, 1, 4294967295, 4294967295, 1, 209, 8, 3871, 1, 4294967295, 4294967295, 1, 209, 8, 3872, 1, 4294967295, 4294967295, 1, 209, 8, 3873, 1, 4294967295, 4294967295, 1, 210, 32, 3874, 1, 4294967295, 4294967295, 1, 210, 8, 3875, 1, 4294967295, 4294967295, 1, 210, 8, 3876, 1, 4294967295, 4294967295, 1, 211, 32, 3877, 1, 4294967295, 4294967295, 1, 211, 32, 3878, 1, 4294967295, 4294967295, 1, 211, 8, 3879, 1, 4294967295, 4294967295, 1, 211, 32, 3880, 1, 4294967295, 4294967295, 1, 211, 8, 3881, 1, 4294967295, 4294967295, 1, 212, 32, 3882, 1, 4294967295, 4294967295, 1, 212, 32, 3883, 1, 4294967295, 4294967295, 1, 212, 8, 3884, 1, 4294967295, 4294967295, 1, 212, 32, 3885, 1, 4294967295, 4294967295, 1, 212, 8, 3886, 1, 4294967295, 4294967295, 1, 212, 32, 3887, 1, 4294967295, 4294967295, 1, 212, 8, 3888, 1, 4294967295, 4294967295, 1, 213, 32, 3889, 1, 4294967295, 4294967295, 1, 213, 32, 3890, 1, 4294967295, 4294967295, 1, 213, 8, 3891, 1, 4294967295, 4294967295, 1, 213, 32, 3892, 1, 4294967295, 4294967295, 1, 213, 8, 3893, 1, 4294967295, 4294967295, 1, 214, 32, 3894, 1, 4294967295, 4294967295, 1, 214, 8, 3895, 1, 4294967295, 4294967295, 1, 214, 8, 3896, 1, 4294967295, 4294967295, 3, 214, 8, 3897, 2, 2921, 4294967295, 8, 214, 8, 3899, 1, 4294967295, 4294967295, 1, 215, 8, 3900, 1, 4294967295, 4294967295, 1, 215, 8, 3901, 1, 4294967295, 4294967295, 3, 215, 8, 3902, 2, 2925, 4294967295, 8, 215, 8, 3904, 1, 4294967295, 4294967295, 1, 215, 32, 3905, 1, 4294967295, 4294967295, 1, 215, 8, 3906, 1, 4294967295, 4294967295, 1, 215, 8, 3907, 1, 4294967295, 4294967295, 1, 216, 32, 3908, 1, 4294967295, 4294967295, 1, 216, 8, 3909, 1, 4294967295, 4294967295, 1, 216, 8, 3910, 1, 4294967295, 4294967295, 1, 217, 32, 3911, 1, 4294967295, 4294967295, 1, 217, 8, 3912, 1, 4294967295, 4294967295, 1, 217, 32, 3913, 1, 4294967295, 4294967295, 1, 217, 8, 3914, 1, 4294967295, 4294967295, 4, 217, 8, 3915, 1, 2937, 4294967295, 8, 217, 8, 3916, 1, 4294967295, 4294967295, 11, 217, 8, 3917, 2, 4294967295, 4294967295, 12, 217, 8, 3919, 1, 4294967295, 2938, 1, 217, 32, 3920, 1, 4294967295, 4294967295, 1, 217, 8, 3921, 1, 4294967295, 4294967295, 1, 218, 32, 3922, 1, 4294967295, 4294967295, 1, 218, 32, 3923, 1, 4294967295, 4294967295, 1, 218, 8, 3924, 1, 4294967295, 4294967295, 1, 218, 32, 3925, 1, 4294967295, 4294967295, 1, 218, 8, 3926, 1, 4294967295, 4294967295, 1, 219, 32, 3927, 1, 4294967295, 4294967295, 1, 219, 32, 3928, 1, 4294967295, 4294967295, 1, 219, 8, 3929, 1, 4294967295, 4294967295, 1, 219, 32, 3930, 1, 4294967295, 4294967295, 1, 219, 8, 3931, 1, 4294967295, 4294967295, 1, 220, 8, 3932, 1, 4294967295, 4294967295, 1, 220, 8, 3933, 1, 4294967295, 4294967295, 1, 220, 8, 3934, 1, 4294967295, 4294967295, 1, 220, 8, 3935, 1, 4294967295, 4294967295, 1, 220, 8, 3936, 1, 4294967295, 4294967295, 1, 220, 8, 3937, 1, 4294967295, 4294967295, 1, 220, 8, 3938, 1, 4294967295, 4294967295, 3, 220, 8, 3939, 7, 2960, 4294967295, 8, 220, 8, 3946, 1, 4294967295, 4294967295, 1, 221, 32, 3947, 1, 4294967295, 4294967295, 1, 221, 8, 3948, 1, 4294967295, 4294967295, 1, 222, 32, 3949, 1, 4294967295, 4294967295, 1, 222, 32, 3950, 1, 4294967295, 4294967295, 1, 222, 32, 3951, 1, 4294967295, 4294967295, 1, 222, 32, 3952, 1, 4294967295, 4294967295, 1, 222, 32, 3953, 1, 4294967295, 4294967295, 1, 222, 32, 3954, 1, 4294967295, 4294967295, 1, 222, 32, 3955, 1, 4294967295, 4294967295, 1, 222, 32, 3956, 1, 4294967295, 4294967295, 1, 222, 32, 3957, 1, 4294967295, 4294967295, 1, 222, 32, 3958, 1, 4294967295, 4294967295, 1, 222, 32, 3959, 1, 4294967295, 4294967295, 1, 222, 32, 3960, 1, 4294967295, 4294967295, 1, 222, 32, 3961, 1, 4294967295, 4294967295, 1, 222, 32, 3962, 1, 4294967295, 4294967295, 1, 222, 32, 3963, 1, 4294967295, 4294967295, 1, 222, 32, 3964, 1, 4294967295, 4294967295, 1, 222, 32, 3965, 1, 4294967295, 4294967295, 1, 222, 32, 3966, 1, 4294967295, 4294967295, 1, 222, 32, 3967, 1, 4294967295, 4294967295, 1, 222, 32, 3968, 1, 4294967295, 4294967295, 1, 222, 32, 3969, 1, 4294967295, 4294967295, 1, 222, 32, 3970, 1, 4294967295, 4294967295, 1, 222, 32, 3971, 1, 4294967295, 4294967295, 1, 222, 32, 3972, 1, 4294967295, 4294967295, 1, 222, 32, 3973, 1, 4294967295, 4294967295, 1, 222, 32, 3974, 1, 4294967295, 4294967295, 1, 222, 32, 3975, 1, 4294967295, 4294967295, 1, 222, 32, 3976, 1, 4294967295, 4294967295, 1, 222, 32, 3977, 1, 4294967295, 4294967295, 1, 222, 32, 3978, 1, 4294967295, 4294967295, 1, 222, 32, 3979, 1, 4294967295, 4294967295, 1, 222, 32, 3980, 1, 4294967295, 4294967295, 1, 222, 32, 3981, 1, 4294967295, 4294967295, 1, 222, 32, 3982, 1, 4294967295, 4294967295, 1, 222, 32, 3983, 1, 4294967295, 4294967295, 1, 222, 32, 3984, 1, 4294967295, 4294967295, 1, 222, 32, 3985, 1, 4294967295, 4294967295, 1, 222, 32, 3986, 1, 4294967295, 4294967295, 1, 222, 32, 3987, 1, 4294967295, 4294967295, 1, 222, 32, 3988, 1, 4294967295, 4294967295, 1, 222, 32, 3989, 1, 4294967295, 4294967295, 1, 222, 32, 3990, 1, 4294967295, 4294967295, 1, 222, 32, 3991, 1, 4294967295, 4294967295, 1, 222, 32, 3992, 1, 4294967295, 4294967295, 1, 222, 32, 3993, 1, 4294967295, 4294967295, 1, 222, 32, 3994, 1, 4294967295, 4294967295, 1, 222, 32, 3995, 1, 4294967295, 4294967295, 1, 222, 32, 3996, 1, 4294967295, 4294967295, 1, 222, 32, 3997, 1, 4294967295, 4294967295, 1, 222, 32, 3998, 1, 4294967295, 4294967295, 1, 222, 32, 3999, 1, 4294967295, 4294967295, 1, 222, 32, 4000, 1, 4294967295, 4294967295, 1, 222, 32, 4001, 1, 4294967295, 4294967295, 1, 222, 32, 4002, 1, 4294967295, 4294967295, 1, 222, 32, 4003, 1, 4294967295, 4294967295, 1, 222, 32, 4004, 1, 4294967295, 4294967295, 1, 222, 32, 4005, 1, 4294967295, 4294967295, 1, 222, 32, 4006, 1, 4294967295, 4294967295, 1, 222, 32, 4007, 1, 4294967295, 4294967295, 1, 222, 32, 4008, 1, 4294967295, 4294967295, 1, 222, 32, 4009, 1, 4294967295, 4294967295, 1, 222, 32, 4010, 1, 4294967295, 4294967295, 1, 222, 32, 4011, 1, 4294967295, 4294967295, 1, 222, 32, 4012, 1, 4294967295, 4294967295, 1, 222, 8, 4013, 1, 4294967295, 4294967295, 3, 222, 8, 4014, 65, 3029, 4294967295, 8, 222, 8, 4079, 1, 4294967295, 4294967295, 1, 223, 8, 4080, 1, 4294967295, 4294967295, 1, 223, 8, 4081, 1, 4294967295, 4294967295, 3, 223, 8, 4082, 2, 3033, 4294967295, 8, 223, 8, 4084, 1, 4294967295, 4294967295, 1, 224, 8, 4085, 1, 4294967295, 4294967295, 1, 224, 8, 4086, 1, 4294967295, 4294967295, 1, 224, 32, 4087, 1, 4294967295, 4294967295, 3, 224, 8, 4088, 3, 3038, 4294967295, 8, 224, 8, 4091, 1, 4294967295, 4294967295, 1, 225, 32, 4092, 1, 4294967295, 4294967295, 1, 225, 8, 4093, 1, 4294967295, 4294967295, 1, 226, 32, 4094, 1, 4294967295, 4294967295, 1, 226, 8, 4095, 1, 4294967295, 4294967295, 1, 227, 32, 4096, 1, 4294967295, 4294967295, 1, 227, 8, 4097, 1, 4294967295, 4294967295, 1, 228, 32, 4098, 1, 4294967295, 4294967295, 1, 228, 8, 4099, 1, 4294967295, 4294967295, 1, 229, 8, 4100, 1, 4294967295, 4294967295, 1, 229, 8, 4101, 1, 4294967295, 4294967295, 3, 229, 8, 4102, 2, 3050, 4294967295, 8, 229, 8, 4104, 1, 4294967295, 4294967295, 1, 230, 32, 4105, 1, 4294967295, 4294967295, 1, 230, 8, 4106, 1, 4294967295, 4294967295, 1, 231, 32, 4107, 1, 4294967295, 4294967295, 1, 231, 8, 4108, 1, 4294967295, 4294967295, 1, 232, 32, 4109, 1, 4294967295, 4294967295, 1, 232, 32, 4110, 1, 4294967295, 4294967295, 1, 232, 32, 4111, 1, 4294967295, 4294967295, 1, 232, 32, 4112, 1, 4294967295, 4294967295, 1, 232, 32, 4113, 1, 4294967295, 4294967295, 1, 232, 32, 4114, 1, 4294967295, 4294967295, 1, 232, 32, 4115, 1, 4294967295, 4294967295, 1, 232, 32, 4116, 1, 4294967295, 4294967295, 1, 232, 32, 4117, 1, 4294967295, 4294967295, 1, 232, 32, 4118, 1, 4294967295, 4294967295, 1, 232, 32, 4119, 1, 4294967295, 4294967295, 1, 232, 32, 4120, 1, 4294967295, 4294967295, 1, 232, 32, 4121, 1, 4294967295, 4294967295, 1, 232, 32, 4122, 1, 4294967295, 4294967295, 1, 232, 32, 4123, 1, 4294967295, 4294967295, 1, 232, 32, 4124, 1, 4294967295, 4294967295, 1, 232, 32, 4125, 1, 4294967295, 4294967295, 1, 232, 32, 4126, 1, 4294967295, 4294967295, 1, 232, 32, 4127, 1, 4294967295, 4294967295, 1, 232, 32, 4128, 1, 4294967295, 4294967295, 1, 232, 32, 4129, 1, 4294967295, 4294967295, 1, 232, 32, 4130, 1, 4294967295, 4294967295, 1, 232, 32, 4131, 1, 4294967295, 4294967295, 1, 232, 32, 4132, 1, 4294967295, 4294967295, 1, 232, 32, 4133, 1, 4294967295, 4294967295, 1, 232, 8, 4134, 1, 4294967295, 4294967295, 1, 232, 8, 4135, 1, 4294967295, 4294967295, 1, 232, 8, 4136, 1, 4294967295, 4294967295, 1, 232, 8, 4137, 1, 4294967295, 4294967295, 1, 232, 32, 4138, 1, 4294967295, 4294967295, 1, 232, 32, 4139, 1, 4294967295, 4294967295, 1, 232, 32, 4140, 1, 4294967295, 4294967295, 1, 232, 32, 4141, 1, 4294967295, 4294967295, 1, 232, 32, 4142, 1, 4294967295, 4294967295, 1, 232, 32, 4143, 1, 4294967295, 4294967295, 1, 232, 32, 4144, 1, 4294967295, 4294967295, 1, 232, 32, 4145, 1, 4294967295, 4294967295, 1, 232, 32, 4146, 1, 4294967295, 4294967295, 1, 232, 32, 4147, 1, 4294967295, 4294967295, 3, 232, 8, 4148, 39, 3095, 4294967295, 8, 232, 8, 4187, 1, 4294967295, 4294967295, 1, 233, 32, 4188, 1, 4294967295, 4294967295, 1, 233, 8, 4189, 1, 4294967295, 4294967295, 1, 234, 32, 4190, 1, 4294967295, 4294967295, 1, 234, 8, 4191, 1, 4294967295, 4294967295, 1, 235, 32, 4192, 1, 4294967295, 4294967295, 1, 235, 8, 4193, 1, 4294967295, 4294967295, 1, 236, 32, 4194, 1, 4294967295, 4294967295, 1, 236, 8, 4195, 1, 4294967295, 4294967295, 1, 237, 32, 4196, 1, 4294967295, 4294967295, 1, 237, 8, 4197, 1, 4294967295, 4294967295, 1, 238, 32, 4198, 1, 4294967295, 4294967295, 1, 238, 32, 4199, 1, 4294967295, 4294967295, 1, 238, 72, 4200, 1, 4294967295, 4294967295, 1, 238, 8, 4201, 1, 4294967295, 4294967295, 1, 239, 32, 4202, 1, 4294967295, 4294967295, 1, 239, 32, 4203, 1, 4294967295, 4294967295, 1, 239, 72, 4204, 1, 4294967295, 4294967295, 1, 239, 32, 4205, 1, 4294967295, 4294967295, 1, 239, 72, 4206, 1, 4294967295, 4294967295, 1, 239, 8, 4207, 1, 4294967295, 4294967295, 1, 240, 32, 4208, 1, 4294967295, 4294967295, 1, 240, 32, 4209, 1, 4294967295, 4294967295, 1, 240, 72, 4210, 1, 4294967295, 4294967295, 1, 240, 8, 4211, 1, 4294967295, 4294967295, 1, 241, 32, 4212, 1, 4294967295, 4294967295, 1, 241, 32, 4213, 1, 4294967295, 4294967295, 1, 241, 72, 4214, 1, 4294967295, 4294967295, 1, 241, 32, 4215, 1, 4294967295, 4294967295, 1, 241, 72, 4216, 1, 4294967295, 4294967295, 1, 241, 8, 4217, 1, 4294967295, 4294967295, 1, 242, 8, 4218, 1, 4294967295, 4294967295, 1, 242, 8, 4219, 1, 4294967295, 4294967295, 1, 242, 32, 4220, 1, 4294967295, 4294967295, 1, 242, 8, 4221, 1, 4294967295, 4294967295, 5, 242, 8, 4222, 1, 3131, 4294967295, 8, 242, 8, 4223, 1, 4294967295, 4294967295, 10, 242, 8, 4224, 2, 4294967295, 4294967295, 12, 242, 8, 4226, 1, 4294967295, 3134, 9, 242, 8, 4227, 1, 4294967295, 4294967295, 1, 243, 8, 4228, 1, 4294967295, 4294967295, 1, 243, 8, 4229, 1, 4294967295, 4294967295, 3, 243, 8, 4230, 2, 3138, 4294967295, 8, 243, 8, 4232, 1, 4294967295, 4294967295, 1, 243, 0, 4233, 0, 4294967295, 4294967295, 1, 491, 0, 0, 0, 1, 514, 0, 0, 0, 1, 490, 0, 0, 0, 1, 1067, 0, 0, 0, 1, 1100, 0, 0, 0, 1, 520, 0, 0, 0, 1, 496, 0, 0, 0, 1, 1073, 0, 0, 0, 1, 1106, 0, 0, 0, 1, 533, 0, 0, 0, 1, 529, 0, 0, 0, 1, 617, 0, 0, 0, 1, 2562, 0, 0, 0, 1, 538, 0, 0, 0, 1, 534, 0, 0, 0, 1, 575, 0, 0, 0, 1, 581, 0, 0, 0, 1, 626, 0, 0, 0, 1, 933, 0, 0, 0, 1, 1775, 0, 0, 0, 1, 1835, 0, 0, 0, 1, 540, 0, 0, 0, 1, 502, 0, 0, 0, 1, 647, 0, 0, 0, 1, 703, 0, 0, 0, 1, 725, 0, 0, 0, 1, 762, 0, 0, 0, 1, 805, 0, 0, 0, 1, 823, 0, 0, 0, 1, 855, 0, 0, 0, 1, 877, 0, 0, 0, 1, 922, 0, 0, 0, 1, 983, 0, 0, 0, 1, 1052, 0, 0, 0, 1, 1085, 0, 0, 0, 1, 1127, 0, 0, 0, 1, 1158, 0, 0, 0, 1, 1178, 0, 0, 0, 1, 1213, 0, 0, 0, 1, 1248, 0, 0, 0, 1, 1303, 0, 0, 0, 1, 1327, 0, 0, 0, 1, 1369, 0, 0, 0, 1, 1403, 0, 0, 0, 1, 1445, 0, 0, 0, 1, 1490, 0, 0, 0, 1, 1532, 0, 0, 0, 1, 1574, 0, 0, 0, 1, 1601, 0, 0, 0, 1, 1703, 0, 0, 0, 1, 1768, 0, 0, 0, 1, 1780, 0, 0, 0, 1, 1793, 0, 0, 0, 1, 1811, 0, 0, 0, 1, 1828, 0, 0, 0, 1, 1840, 0, 0, 0, 1, 1854, 0, 0, 0, 1, 1862, 0, 0, 0, 1, 1871, 0, 0, 0, 1, 1883, 0, 0, 0, 1, 1924, 0, 0, 0, 1, 1939, 0, 0, 0, 1, 1956, 0, 0, 0, 1, 1966, 0, 0, 0, 1, 1987, 0, 0, 0, 1, 2017, 0, 0, 0, 1, 2029, 0, 0, 0, 1, 2041, 0, 0, 0, 1, 2244, 0, 0, 0, 1, 2256, 0, 0, 0, 1, 2297, 0, 0, 0, 1, 2306, 0, 0, 0, 1, 2324, 0, 0, 0, 1, 2336, 0, 0, 0, 1, 2506, 0, 0, 0, 1, 2527, 0, 0, 0, 1, 554, 0, 0, 0, 1, 543, 0, 0, 0, 1, 557, 0, 0, 0, 1, 549, 0, 0, 0, 1, 548, 0, 0, 0, 1, 564, 0, 0, 0, 1, 559, 0, 0, 0, 1, 851, 0, 0, 0, 1, 1064, 0, 0, 0, 1, 1097, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 574, 0, 0, 0, 1, 565, 0, 0, 0, 1, 580, 0, 0, 0, 1, 565, 0, 0, 0, 1, 570, 0, 0, 0, 1, 577, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2790, 0, 0, 0, 1, 582, 0, 0, 0, 1, 581, 0, 0, 0, 1, 585, 0, 0, 0, 1, 584, 0, 0, 0, 1, 602, 0, 0, 0, 1, 560, 0, 0, 0, 1, 621, 0, 0, 0, 1, 608, 0, 0, 0, 1, 607, 0, 0, 0, 1, 625, 0, 0, 0, 1, 620, 0, 0, 0, 1, 692, 0, 0, 0, 1, 2186, 0, 0, 0, 1, 639, 0, 0, 0, 1, 508, 0, 0, 0, 1, 1079, 0, 0, 0, 1, 1112, 0, 0, 0, 1, 1357, 0, 0, 0, 1, 1395, 0, 0, 0, 1, 1433, 0, 0, 0, 1, 1478, 0, 0, 0, 1, 1520, 0, 0, 0, 1, 1562, 0, 0, 0, 1, 643, 0, 0, 0, 1, 640, 0, 0, 0, 1, 648, 0, 0, 0, 1, 644, 0, 0, 0, 1, 661, 0, 0, 0, 1, 653, 0, 0, 0, 1, 709, 0, 0, 0, 1, 731, 0, 0, 0, 1, 772, 0, 0, 0, 1, 829, 0, 0, 0, 1, 861, 0, 0, 0, 1, 883, 0, 0, 0, 1, 989, 0, 0, 0, 1, 1058, 0, 0, 0, 1, 1091, 0, 0, 0, 1, 1133, 0, 0, 0, 1, 1164, 0, 0, 0, 1, 1184, 0, 0, 0, 1, 1219, 0, 0, 0, 1, 1254, 0, 0, 0, 1, 1309, 0, 0, 0, 1, 1333, 0, 0, 0, 1, 1375, 0, 0, 0, 1, 1409, 0, 0, 0, 1, 1451, 0, 0, 0, 1, 1496, 0, 0, 0, 1, 1538, 0, 0, 0, 1, 1580, 0, 0, 0, 1, 1607, 0, 0, 0, 1, 1709, 0, 0, 0, 1, 1978, 0, 0, 0, 1, 1993, 0, 0, 0, 1, 2488, 0, 0, 0, 1, 2512, 0, 0, 0, 1, 2533, 0, 0, 0, 1, 3029, 0, 0, 0, 1, 663, 0, 0, 0, 1, 659, 0, 0, 0, 1, 714, 0, 0, 0, 1, 1878, 0, 0, 0, 1, 1891, 0, 0, 0, 1, 2318, 0, 0, 0, 1, 672, 0, 0, 0, 1, 669, 0, 0, 0, 1, 668, 0, 0, 0, 1, 679, 0, 0, 0, 1, 675, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2661, 0, 0, 0, 1, 2676, 0, 0, 0, 1, 691, 0, 0, 0, 1, 685, 0, 0, 0, 1, 684, 0, 0, 0, 1, 796, 0, 0, 0, 1, 795, 0, 0, 0, 1, 2936, 0, 0, 0, 1, 2937, 0, 0, 0, 1, 698, 0, 0, 0, 1, 678, 0, 0, 0, 1, 785, 0, 0, 0, 1, 1230, 0, 0, 0, 1, 1237, 0, 0, 0, 1, 1316, 0, 0, 0, 1, 3138, 0, 0, 0, 1, 704, 0, 0, 0, 1, 644, 0, 0, 0, 1, 721, 0, 0, 0, 1, 640, 0, 0, 0, 1, 726, 0, 0, 0, 1, 722, 0, 0, 0, 1, 747, 0, 0, 0, 1, 738, 0, 0, 0, 1, 848, 0, 0, 0, 1, 873, 0, 0, 0, 1, 899, 0, 0, 0, 1, 1044, 0, 0, 0, 1, 1344, 0, 0, 0, 1, 1385, 0, 0, 0, 1, 1420, 0, 0, 0, 1, 1465, 0, 0, 0, 1, 1507, 0, 0, 0, 1, 1549, 0, 0, 0, 1, 1594, 0, 0, 0, 1, 2006, 0, 0, 0, 1, 2495, 0, 0, 0, 1, 2520, 0, 0, 0, 1, 763, 0, 0, 0, 1, 753, 0, 0, 0, 1, 752, 0, 0, 0, 1, 1206, 0, 0, 0, 1, 1205, 0, 0, 0, 1, 786, 0, 0, 0, 1, 739, 0, 0, 0, 1, 790, 0, 0, 0, 1, 789, 0, 0, 0, 1, 1298, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2596, 0, 0, 0, 1, 2602, 0, 0, 0, 1, 2651, 0, 0, 0, 1, 806, 0, 0, 0, 1, 746, 0, 0, 0, 1, 849, 0, 0, 0, 1, 874, 0, 0, 0, 1, 908, 0, 0, 0, 1, 1045, 0, 0, 0, 1, 1175, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1786, 0, 0, 0, 1, 2014, 0, 0, 0, 1, 2265, 0, 0, 0, 1, 2279, 0, 0, 0, 1, 2294, 0, 0, 0, 1, 2303, 0, 0, 0, 1, 2498, 0, 0, 0, 1, 2524, 0, 0, 0, 1, 2542, 0, 0, 0, 1, 818, 0, 0, 0, 1, 742, 0, 0, 0, 1, 845, 0, 0, 0, 1, 870, 0, 0, 0, 1, 904, 0, 0, 0, 1, 1041, 0, 0, 0, 1, 1171, 0, 0, 0, 1, 1196, 0, 0, 0, 1, 1237, 0, 0, 0, 1, 2011, 0, 0, 0, 1, 824, 0, 0, 0, 1, 722, 0, 0, 0, 1, 850, 0, 0, 0, 1, 836, 0, 0, 0, 1, 890, 0, 0, 0, 1, 996, 0, 0, 0, 1, 1141, 0, 0, 0, 1, 1191, 0, 0, 0, 1, 1226, 0, 0, 0, 1, 856, 0, 0, 0, 1, 722, 0, 0, 0, 1, 878, 0, 0, 0, 1, 722, 0, 0, 0, 1, 909, 0, 0, 0, 1, 894, 0, 0, 0, 1, 1341, 0, 0, 0, 1, 1382, 0, 0, 0, 1, 1417, 0, 0, 0, 1, 1462, 0, 0, 0, 1, 1504, 0, 0, 0, 1, 1546, 0, 0, 0, 1, 1589, 0, 0, 0, 1, 2001, 0, 0, 0, 1, 923, 0, 0, 0, 1, 915, 0, 0, 0, 1, 914, 0, 0, 0, 1, 931, 0, 0, 0, 1, 898, 0, 0, 0, 1, 1350, 0, 0, 0, 1, 1388, 0, 0, 0, 1, 1426, 0, 0, 0, 1, 1471, 0, 0, 0, 1, 1513, 0, 0, 0, 1, 1555, 0, 0, 0, 1, 1593, 0, 0, 0, 1, 2005, 0, 0, 0, 1, 947, 0, 0, 0, 1, 939, 0, 0, 0, 1, 938, 0, 0, 0, 1, 949, 0, 0, 0, 1, 948, 0, 0, 0, 1, 958, 0, 0, 0, 1, 955, 0, 0, 0, 1, 954, 0, 0, 0, 1, 960, 0, 0, 0, 1, 959, 0, 0, 0, 1, 971, 0, 0, 0, 1, 948, 0, 0, 0, 1, 973, 0, 0, 0, 1, 948, 0, 0, 0, 1, 977, 0, 0, 0, 1, 948, 0, 0, 0, 1, 979, 0, 0, 0, 1, 948, 0, 0, 0, 1, 984, 0, 0, 0, 1, 722, 0, 0, 0, 1, 1048, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1053, 0, 0, 0, 1, 1049, 0, 0, 0, 1, 1086, 0, 0, 0, 1, 1049, 0, 0, 0, 1, 1123, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1128, 0, 0, 0, 1, 1124, 0, 0, 0, 1, 1147, 0, 0, 0, 1, 1146, 0, 0, 0, 1, 1199, 0, 0, 0, 1, 1232, 0, 0, 0, 1, 1159, 0, 0, 0, 1, 1150, 0, 0, 0, 1, 1179, 0, 0, 0, 1, 1124, 0, 0, 0, 1, 1200, 0, 0, 0, 1, 1198, 0, 0, 0, 1, 1214, 0, 0, 0, 1, 1124, 0, 0, 0, 1, 1244, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1249, 0, 0, 0, 1, 1245, 0, 0, 0, 1, 1283, 0, 0, 0, 1, 1262, 0, 0, 0, 1, 1347, 0, 0, 0, 1, 1423, 0, 0, 0, 1, 1468, 0, 0, 0, 1, 1510, 0, 0, 0, 1, 1552, 0, 0, 0, 1, 1294, 0, 0, 0, 1, 1289, 0, 0, 0, 1, 1288, 0, 0, 0, 1, 1296, 0, 0, 0, 1, 1295, 0, 0, 0, 1, 1299, 0, 0, 0, 1, 1295, 0, 0, 0, 1, 1304, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1269, 0, 0, 0, 1, 1268, 0, 0, 0, 1, 1323, 0, 0, 0, 1, 1245, 0, 0, 0, 1, 1328, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1370, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1404, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1446, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1491, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1533, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1324, 0, 0, 0, 1, 1575, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1602, 0, 0, 0, 1, 640, 0, 0, 0, 1, 1620, 0, 0, 0, 1, 531, 0, 0, 0, 1, 588, 0, 0, 0, 1, 592, 0, 0, 0, 1, 664, 0, 0, 0, 1, 778, 0, 0, 0, 1, 842, 0, 0, 0, 1, 889, 0, 0, 0, 1, 980, 0, 0, 0, 1, 995, 0, 0, 0, 1, 1140, 0, 0, 0, 1, 1190, 0, 0, 0, 1, 1225, 0, 0, 0, 1, 1297, 0, 0, 0, 1, 1300, 0, 0, 0, 1, 1586, 0, 0, 0, 1, 1639, 0, 0, 0, 1, 1714, 0, 0, 0, 1, 1722, 0, 0, 0, 1, 1725, 0, 0, 0, 1, 1738, 0, 0, 0, 1, 1803, 0, 0, 0, 1, 1998, 0, 0, 0, 1, 2105, 0, 0, 0, 1, 2155, 0, 0, 0, 1, 2225, 0, 0, 0, 1, 2283, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2518, 0, 0, 0, 1, 2601, 0, 0, 0, 1, 2608, 0, 0, 0, 1, 2653, 0, 0, 0, 1, 2658, 0, 0, 0, 1, 2821, 0, 0, 0, 1, 2846, 0, 0, 0, 1, 2910, 0, 0, 0, 1, 2915, 0, 0, 0, 1, 2920, 0, 0, 0, 1, 2945, 0, 0, 0, 1, 3127, 0, 0, 0, 1, 1637, 0, 0, 0, 1, 2568, 0, 0, 0, 1, 1643, 0, 0, 0, 1, 1625, 0, 0, 0, 1, 1640, 0, 0, 0, 1, 1660, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1675, 0, 0, 0, 1, 1664, 0, 0, 0, 1, 1677, 0, 0, 0, 1, 1670, 0, 0, 0, 1, 1674, 0, 0, 0, 1, 1688, 0, 0, 0, 1, 1683, 0, 0, 0, 1, 1682, 0, 0, 0, 1, 1690, 0, 0, 0, 1, 1666, 0, 0, 0, 1, 1704, 0, 0, 0, 1, 1696, 0, 0, 0, 1, 1695, 0, 0, 0, 1, 1715, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1717, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1723, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1726, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1736, 0, 0, 0, 1, 1730, 0, 0, 0, 1, 1731, 0, 0, 0, 1, 1764, 0, 0, 0, 1, 812, 0, 0, 0, 1, 1612, 0, 0, 0, 1, 1808, 0, 0, 0, 1, 1825, 0, 0, 0, 1, 1846, 0, 0, 0, 1, 1880, 0, 0, 0, 1, 1921, 0, 0, 0, 1, 1949, 0, 0, 0, 1, 1953, 0, 0, 0, 1, 1963, 0, 0, 0, 1, 2026, 0, 0, 0, 1, 2065, 0, 0, 0, 1, 2321, 0, 0, 0, 1, 2333, 0, 0, 0, 1, 1769, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1781, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1789, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1794, 0, 0, 0, 1, 1790, 0, 0, 0, 1, 1812, 0, 0, 0, 1, 1790, 0, 0, 0, 1, 1829, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1841, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1855, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1863, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1872, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1884, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1925, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1940, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1951, 0, 0, 0, 1, 1950, 0, 0, 0, 1, 1957, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1967, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1988, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2018, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2030, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2042, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2059, 0, 0, 0, 1, 2052, 0, 0, 0, 1, 2071, 0, 0, 0, 1, 2060, 0, 0, 0, 1, 2073, 0, 0, 0, 1, 2072, 0, 0, 0, 1, 2092, 0, 0, 0, 1, 2076, 0, 0, 0, 1, 2098, 0, 0, 0, 1, 2137, 0, 0, 0, 1, 2136, 0, 0, 0, 1, 2151, 0, 0, 0, 1, 2182, 0, 0, 0, 1, 2223, 0, 0, 0, 1, 2228, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2924, 0, 0, 0, 1, 2102, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2104, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2110, 0, 0, 0, 1, 2106, 0, 0, 0, 1, 2120, 0, 0, 0, 1, 2119, 0, 0, 0, 1, 2148, 0, 0, 0, 1, 2164, 0, 0, 0, 1, 2231, 0, 0, 0, 1, 2654, 0, 0, 0, 1, 2112, 0, 0, 0, 1, 2111, 0, 0, 0, 1, 2114, 0, 0, 0, 1, 2111, 0, 0, 0, 1, 2127, 0, 0, 0, 1, 2111, 0, 0, 0, 1, 2129, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2131, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2149, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2154, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2165, 0, 0, 0, 1, 2158, 0, 0, 0, 1, 2179, 0, 0, 0, 1, 2171, 0, 0, 0, 1, 2170, 0, 0, 0, 1, 2196, 0, 0, 0, 1, 2195, 0, 0, 0, 1, 2185, 0, 0, 0, 1, 2180, 0, 0, 0, 1, 2187, 0, 0, 0, 1, 2186, 0, 0, 0, 1, 2190, 0, 0, 0, 1, 2161, 0, 0, 0, 1, 2218, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2220, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2224, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2226, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2229, 0, 0, 0, 1, 2093, 0, 0, 0, 1, 2232, 0, 0, 0, 1, 2077, 0, 0, 0, 1, 2925, 0, 0, 0, 1, 2235, 0, 0, 0, 1, 2072, 0, 0, 0, 1, 2239, 0, 0, 0, 1, 2072, 0, 0, 0, 1, 2245, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2257, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2271, 0, 0, 0, 1, 2264, 0, 0, 0, 1, 2280, 0, 0, 0, 1, 2274, 0, 0, 0, 1, 2287, 0, 0, 0, 1, 2277, 0, 0, 0, 1, 2292, 0, 0, 0, 1, 2270, 0, 0, 0, 1, 2298, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2307, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2325, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2337, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 2386, 0, 0, 0, 1, 624, 0, 0, 0, 1, 697, 0, 0, 0, 1, 700, 0, 0, 0, 1, 820, 0, 0, 0, 1, 1646, 0, 0, 0, 1, 1650, 0, 0, 0, 1, 1806, 0, 0, 0, 1, 1821, 0, 0, 0, 1, 1823, 0, 0, 0, 1, 1849, 0, 0, 0, 1, 1867, 0, 0, 0, 1, 1897, 0, 0, 0, 1, 1896, 0, 0, 0, 1, 1907, 0, 0, 0, 1, 1914, 0, 0, 0, 1, 1913, 0, 0, 0, 1, 1934, 0, 0, 0, 1, 1946, 0, 0, 0, 1, 2024, 0, 0, 0, 1, 2036, 0, 0, 0, 1, 2048, 0, 0, 0, 1, 2103, 0, 0, 0, 1, 2188, 0, 0, 0, 1, 2219, 0, 0, 0, 1, 2234, 0, 0, 0, 1, 2237, 0, 0, 0, 1, 2251, 0, 0, 0, 1, 2290, 0, 0, 0, 1, 2318, 0, 0, 0, 1, 2331, 0, 0, 0, 1, 2344, 0, 0, 0, 1, 2374, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2437, 0, 0, 0, 1, 2439, 0, 0, 0, 1, 2456, 0, 0, 0, 1, 2499, 0, 0, 0, 1, 2524, 0, 0, 0, 1, 2542, 0, 0, 0, 1, 2564, 0, 0, 0, 1, 2576, 0, 0, 0, 1, 2575, 0, 0, 0, 1, 2588, 0, 0, 0, 1, 2610, 0, 0, 0, 1, 2614, 0, 0, 0, 1, 2619, 0, 0, 0, 1, 2645, 0, 0, 0, 1, 2648, 0, 0, 0, 1, 2735, 0, 0, 0, 1, 2744, 0, 0, 0, 1, 2786, 0, 0, 0, 1, 2793, 0, 0, 0, 1, 2814, 0, 0, 0, 1, 2825, 0, 0, 0, 1, 2850, 0, 0, 0, 1, 2852, 0, 0, 0, 1, 2855, 0, 0, 0, 1, 2864, 0, 0, 0, 1, 2876, 0, 0, 0, 1, 2880, 0, 0, 0, 1, 2887, 0, 0, 0, 1, 2889, 0, 0, 0, 1, 2892, 0, 0, 0, 1, 2899, 0, 0, 0, 1, 2903, 0, 0, 0, 1, 2908, 0, 0, 0, 1, 2928, 0, 0, 0, 1, 2931, 0, 0, 0, 1, 2950, 0, 0, 0, 1, 2484, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2489, 0, 0, 0, 1, 2485, 0, 0, 0, 1, 2502, 0, 0, 0, 1, 2485, 0, 0, 0, 1, 2507, 0, 0, 0, 1, 2503, 0, 0, 0, 1, 2528, 0, 0, 0, 1, 2503, 0, 0, 0, 1, 2543, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2561, 0, 0, 0, 1, 2550, 0, 0, 0, 1, 2549, 0, 0, 0, 1, 2565, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2570, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2478, 0, 0, 0, 1, 2569, 0, 0, 0, 1, 2597, 0, 0, 0, 1, 2605, 0, 0, 0, 1, 2674, 0, 0, 0, 1, 2681, 0, 0, 0, 1, 2921, 0, 0, 0, 1, 2586, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2591, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2593, 0, 0, 0, 1, 2592, 0, 0, 0, 1, 2598, 0, 0, 0, 1, 2592, 0, 0, 0, 1, 2606, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2621, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2623, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2642, 0, 0, 0, 1, 2629, 0, 0, 0, 1, 2628, 0, 0, 0, 1, 2644, 0, 0, 0, 1, 2643, 0, 0, 0, 1, 2646, 0, 0, 0, 1, 2643, 0, 0, 0, 1, 2649, 0, 0, 0, 1, 2643, 0, 0, 0, 1, 2652, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2655, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2660, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2662, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2664, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2675, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2677, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2684, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2686, 0, 0, 0, 1, 2685, 0, 0, 0, 1, 2688, 0, 0, 0, 1, 2685, 0, 0, 0, 1, 2724, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2728, 0, 0, 0, 1, 2693, 0, 0, 0, 1, 2701, 0, 0, 0, 1, 2709, 0, 0, 0, 1, 2718, 0, 0, 0, 1, 2730, 0, 0, 0, 1, 2729, 0, 0, 0, 1, 2732, 0, 0, 0, 1, 2729, 0, 0, 0, 1, 2742, 0, 0, 0, 1, 2736, 0, 0, 0, 1, 2745, 0, 0, 0, 1, 2739, 0, 0, 0, 1, 2748, 0, 0, 0, 1, 2710, 0, 0, 0, 1, 2750, 0, 0, 0, 1, 2714, 0, 0, 0, 1, 2723, 0, 0, 0, 1, 2757, 0, 0, 0, 1, 2719, 0, 0, 0, 1, 2772, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2774, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2777, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2780, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2783, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2788, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2791, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2813, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2815, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2818, 0, 0, 0, 1, 2816, 0, 0, 0, 1, 2842, 0, 0, 0, 1, 2829, 0, 0, 0, 1, 2817, 0, 0, 0, 1, 2896, 0, 0, 0, 1, 2841, 0, 0, 0, 1, 2828, 0, 0, 0, 1, 2843, 0, 0, 0, 1, 2842, 0, 0, 0, 1, 2857, 0, 0, 0, 1, 2856, 0, 0, 0, 1, 2860, 0, 0, 0, 1, 2842, 0, 0, 0, 1, 2865, 0, 0, 0, 1, 2842, 0, 0, 0, 1, 2874, 0, 0, 0, 1, 2871, 0, 0, 0, 1, 2870, 0, 0, 0, 1, 2878, 0, 0, 0, 1, 2842, 0, 0, 0, 1, 2883, 0, 0, 0, 1, 2834, 0, 0, 0, 1, 2885, 0, 0, 0, 1, 2884, 0, 0, 0, 1, 2890, 0, 0, 0, 1, 2884, 0, 0, 0, 1, 2893, 0, 0, 0, 1, 2835, 0, 0, 0, 1, 2897, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2900, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2905, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2912, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2917, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2922, 0, 0, 0, 1, 2465, 0, 0, 0, 1, 2464, 0, 0, 0, 1, 2929, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2932, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2942, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2947, 0, 0, 0, 1, 2387, 0, 0, 0, 1, 2959, 0, 0, 0, 1, 555, 0, 0, 0, 1, 2961, 0, 0, 0, 1, 517, 0, 0, 0, 1, 539, 0, 0, 0, 1, 583, 0, 0, 0, 1, 674, 0, 0, 0, 1, 736, 0, 0, 0, 1, 782, 0, 0, 0, 1, 867, 0, 0, 0, 1, 893, 0, 0, 0, 1, 930, 0, 0, 0, 1, 1145, 0, 0, 0, 1, 1240, 0, 0, 0, 1, 1261, 0, 0, 0, 1, 1315, 0, 0, 0, 1, 1340, 0, 0, 0, 1, 1416, 0, 0, 0, 1, 1461, 0, 0, 0, 1, 1503, 0, 0, 0, 1, 1545, 0, 0, 0, 1, 1588, 0, 0, 0, 1, 1689, 0, 0, 0, 1, 1739, 0, 0, 0, 1, 1804, 0, 0, 0, 1, 1961, 0, 0, 0, 1, 2000, 0, 0, 0, 1, 2284, 0, 0, 0, 1, 2538, 0, 0, 0, 1, 2823, 0, 0, 0, 1, 2848, 0, 0, 0, 1, 2859, 0, 0, 0, 1, 2862, 0, 0, 0, 1, 2895, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3137, 0, 0, 0, 1, 3028, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3032, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3037, 0, 0, 0, 1, 3033, 0, 0, 0, 1, 3039, 0, 0, 0, 1, 3038, 0, 0, 0, 1, 3041, 0, 0, 0, 1, 3038, 0, 0, 0, 1, 3043, 0, 0, 0, 1, 3033, 0, 0, 0, 1, 3045, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3049, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2781, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3051, 0, 0, 0, 1, 3050, 0, 0, 0, 1, 3053, 0, 0, 0, 1, 3050, 0, 0, 0, 1, 3094, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3096, 0, 0, 0, 1, 2960, 0, 0, 0, 1, 3098, 0, 0, 0, 1, 2731, 0, 0, 0, 1, 2747, 0, 0, 0, 1, 3100, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2775, 0, 0, 0, 1, 3102, 0, 0, 0, 1, 2773, 0, 0, 0, 1, 2778, 0, 0, 0, 1, 3104, 0, 0, 0, 1, 1457, 0, 0, 0, 1, 3106, 0, 0, 0, 1, 1037, 0, 0, 0, 1, 2429, 0, 0, 0, 1, 3095, 0, 0, 0, 1, 3110, 0, 0, 0, 1, 1037, 0, 0, 0, 1, 2429, 0, 0, 0, 1, 3095, 0, 0, 0, 1, 3116, 0, 0, 0, 1, 1037, 0, 0, 0, 1, 2403, 0, 0, 0, 1, 3095, 0, 0, 0, 1, 3120, 0, 0, 0, 1, 1037, 0, 0, 0, 1, 2403, 0, 0, 0, 1, 3095, 0, 0, 0, 1, 3126, 0, 0, 0, 1, 1983, 0, 0, 0, 1, 3135, 0, 0, 0, 1, 3132, 0, 0, 0, 1, 3131, 0, 0, 0, 3, 2, 1, 490, 0, 1, 488, 0, 0, 0, 1, 493, 0, 0, 0, 1, 489, 0, 0, 0, 1, 492, 0, 0, 0, 1, 497, 0, 0, 0, 1, 491, 0, 0, 0, 3, 4, 2, 496, 0, 1, 494, 0, 0, 0, 1, 499, 0, 0, 0, 1, 495, 0, 0, 0, 1, 498, 0, 0, 0, 1, 503, 0, 0, 0, 1, 497, 0, 0, 0, 3, 10, 5, 502, 0, 1, 500, 0, 0, 0, 1, 505, 0, 0, 0, 1, 501, 0, 0, 0, 1, 504, 0, 0, 0, 1, 509, 0, 0, 0, 1, 503, 0, 0, 0, 3, 32, 16, 508, 0, 1, 506, 0, 0, 0, 1, 511, 0, 0, 0, 1, 507, 0, 0, 0, 1, 510, 0, 0, 0, 1, 512, 0, 0, 0, 1, 509, 0, 0, 0, 5, 513, 4294967295, 0, 0, 1, 1, 0, 0, 0, 5, 515, 41, 0, 0, 5, 516, 59, 0, 0, 3, 442, 221, 517, 0, 5, 518, 167, 0, 0, 1, 3, 0, 0, 0, 5, 521, 42, 0, 0, 1, 519, 0, 0, 0, 1, 521, 0, 0, 0, 1, 522, 0, 0, 0, 5, 528, 77, 0, 0, 5, 529, 52, 0, 0, 5, 526, 57, 0, 0, 1, 524, 0, 0, 0, 1, 526, 0, 0, 0, 1, 527, 0, 0, 0, 3, 6, 3, 529, 0, 1, 523, 0, 0, 0, 1, 525, 0, 0, 0, 1, 529, 0, 0, 0, 1, 530, 0, 0, 0, 3, 152, 76, 531, 0, 5, 532, 167, 0, 0, 1, 5, 0, 0, 0, 3, 8, 4, 534, 0, 5, 535, 169, 0, 0, 1, 7, 0, 0, 0, 5, 539, 42, 0, 0, 3, 442, 221, 539, 0, 1, 536, 0, 0, 0, 1, 537, 0, 0, 0, 1, 9, 0, 0, 0, 5, 542, 202, 0, 0, 3, 12, 6, 543, 0, 1, 541, 0, 0, 0, 1, 543, 0, 0, 0, 1, 544, 0, 0, 0, 3, 14, 7, 549, 0, 5, 546, 163, 0, 0, 3, 14, 7, 548, 0, 1, 545, 0, 0, 0, 1, 551, 0, 0, 0, 1, 547, 0, 0, 0, 1, 550, 0, 0, 0, 1, 552, 0, 0, 0, 1, 549, 0, 0, 0, 5, 553, 203, 0, 0, 1, 11, 0, 0, 0, 3, 440, 220, 555, 0, 5, 556, 199, 0, 0, 1, 13, 0, 0, 0, 3, 16, 8, 559, 0, 3, 26, 13, 560, 0, 1, 558, 0, 0, 0, 1, 560, 0, 0, 0, 1, 15, 0, 0, 0, 6, 562, 8, 4294967295, 0, 3, 18, 9, 565, 0, 3, 20, 10, 565, 0, 1, 561, 0, 0, 0, 1, 563, 0, 0, 0, 1, 571, 0, 0, 0, 10, 567, 2, 0, 0, 5, 568, 165, 0, 0, 3, 20, 10, 570, 0, 1, 566, 0, 0, 0, 1, 573, 0, 0, 0, 1, 569, 0, 0, 0, 1, 572, 0, 0, 0, 1, 17, 0, 0, 0, 1, 571, 0, 0, 0, 3, 8, 4, 575, 0, 5, 576, 133, 0, 0, 3, 20, 10, 577, 0, 1, 19, 0, 0, 0, 3, 22, 11, 581, 0, 3, 8, 4, 581, 0, 1, 578, 0, 0, 0, 1, 579, 0, 0, 0, 1, 21, 0, 0, 0, 3, 442, 221, 583, 0, 3, 24, 12, 584, 0, 1, 23, 0, 0, 0, 5, 598, 168, 0, 0, 3, 152, 76, 588, 0, 1, 586, 0, 0, 0, 1, 588, 0, 0, 0, 1, 595, 0, 0, 0, 5, 591, 163, 0, 0, 3, 152, 76, 592, 0, 1, 590, 0, 0, 0, 1, 592, 0, 0, 0, 1, 594, 0, 0, 0, 1, 589, 0, 0, 0, 1, 597, 0, 0, 0, 1, 593, 0, 0, 0, 1, 596, 0, 0, 0, 1, 599, 0, 0, 0, 1, 595, 0, 0, 0, 1, 587, 0, 0, 0, 1, 599, 0, 0, 0, 1, 600, 0, 0, 0, 5, 601, 170, 0, 0, 1, 25, 0, 0, 0, 5, 611, 200, 0, 0, 3, 28, 14, 608, 0, 5, 605, 163, 0, 0, 3, 28, 14, 607, 0, 1, 604, 0, 0, 0, 1, 610, 0, 0, 0, 1, 606, 0, 0, 0, 1, 609, 0, 0, 0, 1, 612, 0, 0, 0, 1, 608, 0, 0, 0, 1, 603, 0, 0, 0, 1, 612, 0, 0, 0, 1, 613, 0, 0, 0, 5, 614, 201, 0, 0, 1, 27, 0, 0, 0, 3, 6, 3, 617, 0, 1, 615, 0, 0, 0, 1, 617, 0, 0, 0, 1, 622, 0, 0, 0, 3, 30, 15, 620, 0, 1, 618, 0, 0, 0, 1, 620, 0, 0, 0, 1, 622, 0, 0, 0, 1, 616, 0, 0, 0, 1, 619, 0, 0, 0, 1, 623, 0, 0, 0, 3, 296, 148, 624, 0, 1, 29, 0, 0, 0, 3, 8, 4, 626, 0, 5, 627, 199, 0, 0, 1, 31, 0, 0, 0, 3, 34, 17, 640, 0, 3, 142, 71, 640, 0, 3, 146, 73, 640, 0, 3, 138, 69, 640, 0, 3, 52, 26, 640, 0, 3, 100, 50, 640, 0, 3, 106, 53, 640, 0, 3, 120, 60, 640, 0, 3, 148, 74, 640, 0, 3, 132, 66, 640, 0, 3, 150, 75, 640, 0, 1, 628, 0, 0, 0, 1, 629, 0, 0, 0, 1, 630, 0, 0, 0, 1, 631, 0, 0, 0, 1, 632, 0, 0, 0, 1, 633, 0, 0, 0, 1, 634, 0, 0, 0, 1, 635, 0, 0, 0, 1, 636, 0, 0, 0, 1, 637, 0, 0, 0, 1, 638, 0, 0, 0, 1, 33, 0, 0, 0, 3, 36, 18, 644, 0, 3, 50, 25, 644, 0, 1, 641, 0, 0, 0, 1, 642, 0, 0, 0, 1, 35, 0, 0, 0, 3, 10, 5, 647, 0, 1, 645, 0, 0, 0, 1, 650, 0, 0, 0, 1, 646, 0, 0, 0, 1, 649, 0, 0, 0, 1, 654, 0, 0, 0, 1, 648, 0, 0, 0, 3, 38, 19, 653, 0, 1, 651, 0, 0, 0, 1, 656, 0, 0, 0, 1, 652, 0, 0, 0, 1, 655, 0, 0, 0, 1, 657, 0, 0, 0, 1, 654, 0, 0, 0, 5, 658, 66, 0, 0, 3, 40, 20, 659, 0, 5, 660, 167, 0, 0, 1, 37, 0, 0, 0, 7, 662, 0, 0, 0, 1, 39, 0, 0, 0, 3, 152, 76, 664, 0, 3, 42, 21, 669, 0, 5, 666, 163, 0, 0, 3, 42, 21, 668, 0, 1, 665, 0, 0, 0, 1, 671, 0, 0, 0, 1, 667, 0, 0, 0, 1, 670, 0, 0, 0, 1, 41, 0, 0, 0, 1, 669, 0, 0, 0, 3, 442, 221, 674, 0, 3, 44, 22, 675, 0, 1, 673, 0, 0, 0, 1, 675, 0, 0, 0, 1, 677, 0, 0, 0, 3, 48, 24, 678, 0, 1, 676, 0, 0, 0, 1, 678, 0, 0, 0, 1, 43, 0, 0, 0, 5, 680, 202, 0, 0, 3, 46, 23, 685, 0, 5, 682, 163, 0, 0, 3, 46, 23, 684, 0, 1, 681, 0, 0, 0, 1, 687, 0, 0, 0, 1, 683, 0, 0, 0, 1, 686, 0, 0, 0, 1, 688, 0, 0, 0, 1, 685, 0, 0, 0, 5, 689, 203, 0, 0, 1, 45, 0, 0, 0, 3, 30, 15, 692, 0, 1, 690, 0, 0, 0, 1, 692, 0, 0, 0, 1, 694, 0, 0, 0, 7, 695, 1, 0, 0, 1, 693, 0, 0, 0, 1, 695, 0, 0, 0, 1, 696, 0, 0, 0, 3, 296, 148, 697, 0, 1, 47, 0, 0, 0, 5, 699, 169, 0, 0, 3, 296, 148, 700, 0, 1, 49, 0, 0, 0, 3, 10, 5, 703, 0, 1, 701, 0, 0, 0, 1, 706, 0, 0, 0, 1, 702, 0, 0, 0, 1, 705, 0, 0, 0, 1, 710, 0, 0, 0, 1, 704, 0, 0, 0, 3, 38, 19, 709, 0, 1, 707, 0, 0, 0, 1, 712, 0, 0, 0, 1, 708, 0, 0, 0, 1, 711, 0, 0, 0, 1, 713, 0, 0, 0, 1, 710, 0, 0, 0, 3, 40, 20, 714, 0, 5, 715, 167, 0, 0, 1, 51, 0, 0, 0, 3, 54, 27, 722, 0, 3, 68, 34, 722, 0, 3, 72, 36, 722, 0, 3, 74, 37, 722, 0, 3, 98, 49, 722, 0, 1, 716, 0, 0, 0, 1, 717, 0, 0, 0, 1, 718, 0, 0, 0, 1, 719, 0, 0, 0, 1, 720, 0, 0, 0, 1, 53, 0, 0, 0, 3, 10, 5, 725, 0, 1, 723, 0, 0, 0, 1, 728, 0, 0, 0, 1, 724, 0, 0, 0, 1, 727, 0, 0, 0, 1, 732, 0, 0, 0, 1, 726, 0, 0, 0, 3, 38, 19, 731, 0, 1, 729, 0, 0, 0, 1, 734, 0, 0, 0, 1, 730, 0, 0, 0, 1, 733, 0, 0, 0, 1, 735, 0, 0, 0, 1, 732, 0, 0, 0, 3, 442, 221, 736, 0, 3, 56, 28, 738, 0, 3, 60, 30, 739, 0, 1, 737, 0, 0, 0, 1, 739, 0, 0, 0, 1, 745, 0, 0, 0, 3, 64, 32, 746, 0, 3, 66, 33, 742, 0, 5, 743, 167, 0, 0, 1, 746, 0, 0, 0, 5, 746, 167, 0, 0, 1, 740, 0, 0, 0, 1, 741, 0, 0, 0, 1, 744, 0, 0, 0, 1, 55, 0, 0, 0, 5, 756, 200, 0, 0, 3, 58, 29, 753, 0, 5, 750, 163, 0, 0, 3, 58, 29, 752, 0, 1, 749, 0, 0, 0, 1, 755, 0, 0, 0, 1, 751, 0, 0, 0, 1, 754, 0, 0, 0, 1, 757, 0, 0, 0, 1, 753, 0, 0, 0, 1, 748, 0, 0, 0, 1, 757, 0, 0, 0, 1, 758, 0, 0, 0, 5, 759, 201, 0, 0, 1, 57, 0, 0, 0, 3, 10, 5, 762, 0, 1, 760, 0, 0, 0, 1, 765, 0, 0, 0, 1, 761, 0, 0, 0, 1, 764, 0, 0, 0, 1, 773, 0, 0, 0, 1, 763, 0, 0, 0, 3, 38, 19, 772, 0, 5, 772, 115, 0, 0, 5, 772, 149, 0, 0, 5, 772, 44, 0, 0, 5, 772, 98, 0, 0, 1, 766, 0, 0, 0, 1, 767, 0, 0, 0, 1, 768, 0, 0, 0, 1, 769, 0, 0, 0, 1, 770, 0, 0, 0, 1, 775, 0, 0, 0, 1, 771, 0, 0, 0, 1, 774, 0, 0, 0, 1, 777, 0, 0, 0, 1, 773, 0, 0, 0, 3, 152, 76, 778, 0, 1, 776, 0, 0, 0, 1, 778, 0, 0, 0, 1, 781, 0, 0, 0, 3, 442, 221, 782, 0, 5, 782, 6, 0, 0, 1, 779, 0, 0, 0, 1, 780, 0, 0, 0, 1, 782, 0, 0, 0, 1, 784, 0, 0, 0, 3, 48, 24, 785, 0, 1, 783, 0, 0, 0, 1, 785, 0, 0, 0, 1, 59, 0, 0, 0, 5, 787, 199, 0, 0, 7, 788, 2, 0, 0, 3, 62, 31, 789, 0, 1, 61, 0, 0, 0, 5, 799, 200, 0, 0, 3, 46, 23, 796, 0, 5, 793, 163, 0, 0, 3, 46, 23, 795, 0, 1, 792, 0, 0, 0, 1, 798, 0, 0, 0, 1, 794, 0, 0, 0, 1, 797, 0, 0, 0, 1, 800, 0, 0, 0, 1, 796, 0, 0, 0, 1, 791, 0, 0, 0, 1, 800, 0, 0, 0, 1, 801, 0, 0, 0, 5, 802, 201, 0, 0, 1, 63, 0, 0, 0, 3, 10, 5, 805, 0, 1, 803, 0, 0, 0, 1, 808, 0, 0, 0, 1, 804, 0, 0, 0, 1, 807, 0, 0, 0, 1, 809, 0, 0, 0, 1, 806, 0, 0, 0, 5, 813, 197, 0, 0, 3, 180, 90, 812, 0, 1, 810, 0, 0, 0, 1, 815, 0, 0, 0, 1, 811, 0, 0, 0, 1, 814, 0, 0, 0, 1, 816, 0, 0, 0, 1, 813, 0, 0, 0, 5, 817, 198, 0, 0, 1, 65, 0, 0, 0, 5, 819, 138, 0, 0, 3, 296, 148, 820, 0, 1, 67, 0, 0, 0, 3, 10, 5, 823, 0, 1, 821, 0, 0, 0, 1, 826, 0, 0, 0, 1, 822, 0, 0, 0, 1, 825, 0, 0, 0, 1, 830, 0, 0, 0, 1, 824, 0, 0, 0, 3, 38, 19, 829, 0, 1, 827, 0, 0, 0, 1, 832, 0, 0, 0, 1, 828, 0, 0, 0, 1, 831, 0, 0, 0, 1, 833, 0, 0, 0, 1, 830, 0, 0, 0, 7, 835, 3, 0, 0, 3, 70, 35, 836, 0, 1, 834, 0, 0, 0, 1, 836, 0, 0, 0, 1, 837, 0, 0, 0, 5, 839, 22, 0, 0, 5, 840, 27, 0, 0, 1, 838, 0, 0, 0, 1, 840, 0, 0, 0, 1, 841, 0, 0, 0, 3, 152, 76, 842, 0, 3, 56, 28, 848, 0, 3, 64, 32, 849, 0, 3, 66, 33, 845, 0, 5, 846, 167, 0, 0, 1, 849, 0, 0, 0, 5, 849, 167, 0, 0, 1, 843, 0, 0, 0, 1, 844, 0, 0, 0, 1, 847, 0, 0, 0, 1, 69, 0, 0, 0, 3, 16, 8, 851, 0, 5, 852, 165, 0, 0, 1, 71, 0, 0, 0, 3, 10, 5, 855, 0, 1, 853, 0, 0, 0, 1, 858, 0, 0, 0, 1, 854, 0, 0, 0, 1, 857, 0, 0, 0, 1, 862, 0, 0, 0, 1, 856, 0, 0, 0, 3, 38, 19, 861, 0, 1, 859, 0, 0, 0, 1, 864, 0, 0, 0, 1, 860, 0, 0, 0, 1, 863, 0, 0, 0, 1, 865, 0, 0, 0, 1, 862, 0, 0, 0, 5, 866, 175, 0, 0, 3, 442, 221, 867, 0, 3, 56, 28, 873, 0, 3, 64, 32, 874, 0, 3, 66, 33, 870, 0, 5, 871, 167, 0, 0, 1, 874, 0, 0, 0, 5, 874, 167, 0, 0, 1, 868, 0, 0, 0, 1, 869, 0, 0, 0, 1, 872, 0, 0, 0, 1, 73, 0, 0, 0, 3, 10, 5, 877, 0, 1, 875, 0, 0, 0, 1, 880, 0, 0, 0, 1, 876, 0, 0, 0, 1, 879, 0, 0, 0, 1, 884, 0, 0, 0, 1, 878, 0, 0, 0, 3, 38, 19, 883, 0, 1, 881, 0, 0, 0, 1, 886, 0, 0, 0, 1, 882, 0, 0, 0, 1, 885, 0, 0, 0, 1, 887, 0, 0, 0, 1, 884, 0, 0, 0, 3, 152, 76, 889, 0, 3, 70, 35, 890, 0, 1, 888, 0, 0, 0, 1, 890, 0, 0, 0, 1, 891, 0, 0, 0, 3, 442, 221, 893, 0, 3, 76, 38, 894, 0, 1, 892, 0, 0, 0, 1, 894, 0, 0, 0, 1, 895, 0, 0, 0, 3, 56, 28, 899, 0, 3, 80, 40, 898, 0, 1, 896, 0, 0, 0, 1, 901, 0, 0, 0, 1, 897, 0, 0, 0, 1, 900, 0, 0, 0, 1, 907, 0, 0, 0, 1, 899, 0, 0, 0, 3, 64, 32, 908, 0, 3, 66, 33, 904, 0, 5, 905, 167, 0, 0, 1, 908, 0, 0, 0, 5, 908, 167, 0, 0, 1, 902, 0, 0, 0, 1, 903, 0, 0, 0, 1, 906, 0, 0, 0, 1, 75, 0, 0, 0, 5, 910, 168, 0, 0, 3, 78, 39, 915, 0, 5, 912, 163, 0, 0, 3, 78, 39, 914, 0, 1, 911, 0, 0, 0, 1, 917, 0, 0, 0, 1, 913, 0, 0, 0, 1, 916, 0, 0, 0, 1, 918, 0, 0, 0, 1, 915, 0, 0, 0, 5, 919, 170, 0, 0, 1, 77, 0, 0, 0, 3, 10, 5, 922, 0, 1, 920, 0, 0, 0, 1, 925, 0, 0, 0, 1, 921, 0, 0, 0, 1, 924, 0, 0, 0, 1, 927, 0, 0, 0, 1, 923, 0, 0, 0, 7, 928, 4, 0, 0, 1, 926, 0, 0, 0, 1, 928, 0, 0, 0, 1, 929, 0, 0, 0, 3, 442, 221, 930, 0, 1, 79, 0, 0, 0, 5, 932, 78, 0, 0, 3, 8, 4, 933, 0, 5, 934, 199, 0, 0, 3, 82, 41, 939, 0, 5, 936, 163, 0, 0, 3, 82, 41, 938, 0, 1, 935, 0, 0, 0, 1, 941, 0, 0, 0, 1, 937, 0, 0, 0, 1, 940, 0, 0, 0, 1, 81, 0, 0, 0, 1, 939, 0, 0, 0, 3, 84, 42, 948, 0, 3, 90, 45, 948, 0, 3, 92, 46, 948, 0, 3, 94, 47, 948, 0, 3, 96, 48, 948, 0, 1, 942, 0, 0, 0, 1, 943, 0, 0, 0, 1, 944, 0, 0, 0, 1, 945, 0, 0, 0, 1, 946, 0, 0, 0, 1, 83, 0, 0, 0, 5, 950, 37, 0, 0, 3, 86, 43, 955, 0, 5, 952, 163, 0, 0, 3, 86, 43, 954, 0, 1, 951, 0, 0, 0, 1, 957, 0, 0, 0, 1, 953, 0, 0, 0, 1, 956, 0, 0, 0, 1, 85, 0, 0, 0, 1, 955, 0, 0, 0, 3, 88, 44, 959, 0, 1, 87, 0, 0, 0, 5, 961, 116, 0, 0, 5, 962, 54, 0, 0, 1, 89, 0, 0, 0, 5, 965, 64, 0, 0, 5, 966, 171, 0, 0, 1, 964, 0, 0, 0, 1, 966, 0, 0, 0, 1, 972, 0, 0, 0, 5, 969, 54, 0, 0, 5, 970, 171, 0, 0, 1, 968, 0, 0, 0, 1, 970, 0, 0, 0, 1, 972, 0, 0, 0, 1, 963, 0, 0, 0, 1, 967, 0, 0, 0, 1, 91, 0, 0, 0, 5, 974, 113, 0, 0, 5, 975, 200, 0, 0, 5, 976, 201, 0, 0, 1, 93, 0, 0, 0, 5, 978, 29, 0, 0, 1, 95, 0, 0, 0, 3, 152, 76, 980, 0, 1, 97, 0, 0, 0, 3, 10, 5, 983, 0, 1, 981, 0, 0, 0, 1, 986, 0, 0, 0, 1, 982, 0, 0, 0, 1, 985, 0, 0, 0, 1, 990, 0, 0, 0, 1, 984, 0, 0, 0, 3, 38, 19, 989, 0, 1, 987, 0, 0, 0, 1, 992, 0, 0, 0, 1, 988, 0, 0, 0, 1, 991, 0, 0, 0, 1, 993, 0, 0, 0, 1, 990, 0, 0, 0, 3, 152, 76, 995, 0, 3, 70, 35, 996, 0, 1, 994, 0, 0, 0, 1, 996, 0, 0, 0, 1, 997, 0, 0, 0, 5, 999, 22, 0, 0, 5, 1000, 27, 0, 0, 1, 998, 0, 0, 0, 1, 1000, 0, 0, 0, 1, 1036, 0, 0, 0, 5, 1037, 162, 0, 0, 5, 1037, 164, 0, 0, 5, 1037, 156, 0, 0, 5, 1037, 175, 0, 0, 5, 1037, 125, 0, 0, 5, 1037, 127, 0, 0, 5, 1037, 161, 0, 0, 5, 1037, 166, 0, 0, 5, 1037, 159, 0, 0, 5, 1037, 135, 0, 0, 3, 476, 238, 1037, 0, 3, 478, 239, 1037, 0, 5, 1037, 174, 0, 0, 5, 1037, 160, 0, 0, 5, 1037, 172, 0, 0, 5, 1037, 137, 0, 0, 5, 1037, 120, 0, 0, 5, 1037, 168, 0, 0, 5, 1037, 136, 0, 0, 5, 1037, 170, 0, 0, 5, 1037, 139, 0, 0, 5, 1037, 67, 0, 0, 5, 1037, 99, 0, 0, 5, 1037, 150, 0, 0, 5, 1037, 126, 0, 0, 5, 1037, 128, 0, 0, 5, 1037, 124, 0, 0, 5, 1037, 131, 0, 0, 5, 1037, 121, 0, 0, 5, 1037, 123, 0, 0, 5, 1037, 154, 0, 0, 5, 1037, 144, 0, 0, 5, 1037, 105, 0, 0, 3, 480, 240, 1037, 0, 3, 482, 241, 1037, 0, 1, 1001, 0, 0, 0, 1, 1002, 0, 0, 0, 1, 1003, 0, 0, 0, 1, 1004, 0, 0, 0, 1, 1005, 0, 0, 0, 1, 1006, 0, 0, 0, 1, 1007, 0, 0, 0, 1, 1008, 0, 0, 0, 1, 1009, 0, 0, 0, 1, 1010, 0, 0, 0, 1, 1011, 0, 0, 0, 1, 1012, 0, 0, 0, 1, 1013, 0, 0, 0, 1, 1014, 0, 0, 0, 1, 1015, 0, 0, 0, 1, 1016, 0, 0, 0, 1, 1017, 0, 0, 0, 1, 1018, 0, 0, 0, 1, 1019, 0, 0, 0, 1, 1020, 0, 0, 0, 1, 1021, 0, 0, 0, 1, 1022, 0, 0, 0, 1, 1023, 0, 0, 0, 1, 1024, 0, 0, 0, 1, 1025, 0, 0, 0, 1, 1026, 0, 0, 0, 1, 1027, 0, 0, 0, 1, 1028, 0, 0, 0, 1, 1029, 0, 0, 0, 1, 1030, 0, 0, 0, 1, 1031, 0, 0, 0, 1, 1032, 0, 0, 0, 1, 1033, 0, 0, 0, 1, 1034, 0, 0, 0, 1, 1035, 0, 0, 0, 1, 1038, 0, 0, 0, 3, 56, 28, 1044, 0, 3, 64, 32, 1045, 0, 3, 66, 33, 1041, 0, 5, 1042, 167, 0, 0, 1, 1045, 0, 0, 0, 5, 1045, 167, 0, 0, 1, 1039, 0, 0, 0, 1, 1040, 0, 0, 0, 1, 1043, 0, 0, 0, 1, 99, 0, 0, 0, 3, 102, 51, 1049, 0, 3, 104, 52, 1049, 0, 1, 1046, 0, 0, 0, 1, 1047, 0, 0, 0, 1, 101, 0, 0, 0, 3, 10, 5, 1052, 0, 1, 1050, 0, 0, 0, 1, 1055, 0, 0, 0, 1, 1051, 0, 0, 0, 1, 1054, 0, 0, 0, 1, 1059, 0, 0, 0, 1, 1053, 0, 0, 0, 3, 38, 19, 1058, 0, 1, 1056, 0, 0, 0, 1, 1061, 0, 0, 0, 1, 1057, 0, 0, 0, 1, 1060, 0, 0, 0, 1, 1062, 0, 0, 0, 1, 1059, 0, 0, 0, 5, 1063, 12, 0, 0, 3, 16, 8, 1064, 0, 5, 1068, 167, 0, 0, 3, 2, 1, 1067, 0, 1, 1065, 0, 0, 0, 1, 1070, 0, 0, 0, 1, 1066, 0, 0, 0, 1, 1069, 0, 0, 0, 1, 1074, 0, 0, 0, 1, 1068, 0, 0, 0, 3, 4, 2, 1073, 0, 1, 1071, 0, 0, 0, 1, 1076, 0, 0, 0, 1, 1072, 0, 0, 0, 1, 1075, 0, 0, 0, 1, 1080, 0, 0, 0, 1, 1074, 0, 0, 0, 3, 32, 16, 1079, 0, 1, 1077, 0, 0, 0, 1, 1082, 0, 0, 0, 1, 1078, 0, 0, 0, 1, 1081, 0, 0, 0, 1, 103, 0, 0, 0, 1, 1080, 0, 0, 0, 3, 10, 5, 1085, 0, 1, 1083, 0, 0, 0, 1, 1088, 0, 0, 0, 1, 1084, 0, 0, 0, 1, 1087, 0, 0, 0, 1, 1092, 0, 0, 0, 1, 1086, 0, 0, 0, 3, 38, 19, 1091, 0, 1, 1089, 0, 0, 0, 1, 1094, 0, 0, 0, 1, 1090, 0, 0, 0, 1, 1093, 0, 0, 0, 1, 1095, 0, 0, 0, 1, 1092, 0, 0, 0, 5, 1096, 12, 0, 0, 3, 16, 8, 1097, 0, 5, 1101, 197, 0, 0, 3, 2, 1, 1100, 0, 1, 1098, 0, 0, 0, 1, 1103, 0, 0, 0, 1, 1099, 0, 0, 0, 1, 1102, 0, 0, 0, 1, 1107, 0, 0, 0, 1, 1101, 0, 0, 0, 3, 4, 2, 1106, 0, 1, 1104, 0, 0, 0, 1, 1109, 0, 0, 0, 1, 1105, 0, 0, 0, 1, 1108, 0, 0, 0, 1, 1113, 0, 0, 0, 1, 1107, 0, 0, 0, 3, 32, 16, 1112, 0, 1, 1110, 0, 0, 0, 1, 1115, 0, 0, 0, 1, 1111, 0, 0, 0, 1, 1114, 0, 0, 0, 1, 1116, 0, 0, 0, 1, 1113, 0, 0, 0, 5, 1118, 198, 0, 0, 5, 1119, 167, 0, 0, 1, 1117, 0, 0, 0, 1, 1119, 0, 0, 0, 1, 105, 0, 0, 0, 3, 108, 54, 1124, 0, 3, 114, 57, 1124, 0, 3, 118, 59, 1124, 0, 1, 1120, 0, 0, 0, 1, 1121, 0, 0, 0, 1, 1122, 0, 0, 0, 1, 107, 0, 0, 0, 3, 10, 5, 1127, 0, 1, 1125, 0, 0, 0, 1, 1130, 0, 0, 0, 1, 1126, 0, 0, 0, 1, 1129, 0, 0, 0, 1, 1134, 0, 0, 0, 1, 1128, 0, 0, 0, 3, 38, 19, 1133, 0, 1, 1131, 0, 0, 0, 1, 1136, 0, 0, 0, 1, 1132, 0, 0, 0, 1, 1135, 0, 0, 0, 1, 1137, 0, 0, 0, 1, 1134, 0, 0, 0, 5, 1138, 66, 0, 0, 3, 152, 76, 1140, 0, 3, 70, 35, 1141, 0, 1, 1139, 0, 0, 0, 1, 1141, 0, 0, 0, 1, 1142, 0, 0, 0, 3, 442, 221, 1145, 0, 3, 110, 55, 1146, 0, 5, 1146, 167, 0, 0, 1, 1143, 0, 0, 0, 1, 1144, 0, 0, 0, 1, 109, 0, 0, 0, 5, 1151, 197, 0, 0, 3, 112, 56, 1150, 0, 1, 1148, 0, 0, 0, 1, 1153, 0, 0, 0, 1, 1149, 0, 0, 0, 1, 1152, 0, 0, 0, 1, 1154, 0, 0, 0, 1, 1151, 0, 0, 0, 5, 1155, 198, 0, 0, 1, 111, 0, 0, 0, 3, 10, 5, 1158, 0, 1, 1156, 0, 0, 0, 1, 1161, 0, 0, 0, 1, 1157, 0, 0, 0, 1, 1160, 0, 0, 0, 1, 1165, 0, 0, 0, 1, 1159, 0, 0, 0, 3, 38, 19, 1164, 0, 1, 1162, 0, 0, 0, 1, 1167, 0, 0, 0, 1, 1163, 0, 0, 0, 1, 1166, 0, 0, 0, 1, 1168, 0, 0, 0, 1, 1165, 0, 0, 0, 7, 1174, 5, 0, 0, 3, 64, 32, 1175, 0, 3, 66, 33, 1171, 0, 5, 1172, 167, 0, 0, 1, 1175, 0, 0, 0, 5, 1175, 167, 0, 0, 1, 1169, 0, 0, 0, 1, 1170, 0, 0, 0, 1, 1173, 0, 0, 0, 1, 113, 0, 0, 0, 3, 10, 5, 1178, 0, 1, 1176, 0, 0, 0, 1, 1181, 0, 0, 0, 1, 1177, 0, 0, 0, 1, 1180, 0, 0, 0, 1, 1185, 0, 0, 0, 1, 1179, 0, 0, 0, 3, 38, 19, 1184, 0, 1, 1182, 0, 0, 0, 1, 1187, 0, 0, 0, 1, 1183, 0, 0, 0, 1, 1186, 0, 0, 0, 1, 1188, 0, 0, 0, 1, 1185, 0, 0, 0, 3, 152, 76, 1190, 0, 3, 70, 35, 1191, 0, 1, 1189, 0, 0, 0, 1, 1191, 0, 0, 0, 1, 1192, 0, 0, 0, 5, 1193, 98, 0, 0, 3, 116, 58, 1198, 0, 3, 110, 55, 1199, 0, 3, 66, 33, 1196, 0, 5, 1197, 167, 0, 0, 1, 1199, 0, 0, 0, 1, 1194, 0, 0, 0, 1, 1195, 0, 0, 0, 1, 115, 0, 0, 0, 5, 1201, 202, 0, 0, 3, 58, 29, 1206, 0, 5, 1203, 163, 0, 0, 3, 58, 29, 1205, 0, 1, 1202, 0, 0, 0, 1, 1208, 0, 0, 0, 1, 1204, 0, 0, 0, 1, 1207, 0, 0, 0, 1, 1209, 0, 0, 0, 1, 1206, 0, 0, 0, 5, 1210, 203, 0, 0, 1, 117, 0, 0, 0, 3, 10, 5, 1213, 0, 1, 1211, 0, 0, 0, 1, 1216, 0, 0, 0, 1, 1212, 0, 0, 0, 1, 1215, 0, 0, 0, 1, 1220, 0, 0, 0, 1, 1214, 0, 0, 0, 3, 38, 19, 1219, 0, 1, 1217, 0, 0, 0, 1, 1222, 0, 0, 0, 1, 1218, 0, 0, 0, 1, 1221, 0, 0, 0, 1, 1223, 0, 0, 0, 1, 1220, 0, 0, 0, 3, 152, 76, 1225, 0, 3, 70, 35, 1226, 0, 1, 1224, 0, 0, 0, 1, 1226, 0, 0, 0, 1, 1227, 0, 0, 0, 3, 442, 221, 1240, 0, 3, 110, 55, 1232, 0, 3, 48, 24, 1230, 0, 5, 1231, 167, 0, 0, 1, 1233, 0, 0, 0, 1, 1229, 0, 0, 0, 1, 1233, 0, 0, 0, 1, 1241, 0, 0, 0, 3, 66, 33, 1237, 0, 3, 48, 24, 1237, 0, 1, 1234, 0, 0, 0, 1, 1235, 0, 0, 0, 1, 1238, 0, 0, 0, 5, 1239, 167, 0, 0, 1, 1241, 0, 0, 0, 1, 1228, 0, 0, 0, 1, 1236, 0, 0, 0, 1, 119, 0, 0, 0, 3, 122, 61, 1245, 0, 3, 134, 67, 1245, 0, 1, 1242, 0, 0, 0, 1, 1243, 0, 0, 0, 1, 121, 0, 0, 0, 3, 10, 5, 1248, 0, 1, 1246, 0, 0, 0, 1, 1251, 0, 0, 0, 1, 1247, 0, 0, 0, 1, 1250, 0, 0, 0, 1, 1255, 0, 0, 0, 1, 1249, 0, 0, 0, 3, 38, 19, 1254, 0, 1, 1252, 0, 0, 0, 1, 1257, 0, 0, 0, 1, 1253, 0, 0, 0, 1, 1256, 0, 0, 0, 1, 1258, 0, 0, 0, 1, 1255, 0, 0, 0, 5, 1259, 87, 0, 0, 3, 442, 221, 1261, 0, 3, 124, 62, 1262, 0, 1, 1260, 0, 0, 0, 1, 1262, 0, 0, 0, 1, 1278, 0, 0, 0, 5, 1275, 197, 0, 0, 3, 132, 66, 1269, 0, 5, 1266, 163, 0, 0, 3, 132, 66, 1268, 0, 1, 1265, 0, 0, 0, 1, 1271, 0, 0, 0, 1, 1267, 0, 0, 0, 1, 1270, 0, 0, 0, 1, 1273, 0, 0, 0, 1, 1269, 0, 0, 0, 5, 1274, 163, 0, 0, 1, 1272, 0, 0, 0, 1, 1274, 0, 0, 0, 1, 1276, 0, 0, 0, 1, 1264, 0, 0, 0, 1, 1276, 0, 0, 0, 1, 1277, 0, 0, 0, 5, 1279, 198, 0, 0, 1, 1263, 0, 0, 0, 1, 1279, 0, 0, 0, 1, 1281, 0, 0, 0, 5, 1282, 167, 0, 0, 1, 1280, 0, 0, 0, 1, 1282, 0, 0, 0, 1, 123, 0, 0, 0, 5, 1284, 199, 0, 0, 3, 126, 63, 1289, 0, 5, 1286, 163, 0, 0, 3, 126, 63, 1288, 0, 1, 1285, 0, 0, 0, 1, 1291, 0, 0, 0, 1, 1287, 0, 0, 0, 1, 1290, 0, 0, 0, 1, 125, 0, 0, 0, 1, 1289, 0, 0, 0, 3, 128, 64, 1295, 0, 3, 130, 65, 1295, 0, 1, 1292, 0, 0, 0, 1, 1293, 0, 0, 0, 1, 127, 0, 0, 0, 3, 152, 76, 1297, 0, 3, 62, 31, 1298, 0, 1, 129, 0, 0, 0, 3, 152, 76, 1300, 0, 1, 131, 0, 0, 0, 3, 10, 5, 1303, 0, 1, 1301, 0, 0, 0, 1, 1306, 0, 0, 0, 1, 1302, 0, 0, 0, 1, 1305, 0, 0, 0, 1, 1310, 0, 0, 0, 1, 1304, 0, 0, 0, 3, 38, 19, 1309, 0, 1, 1307, 0, 0, 0, 1, 1312, 0, 0, 0, 1, 1308, 0, 0, 0, 1, 1311, 0, 0, 0, 1, 1313, 0, 0, 0, 1, 1310, 0, 0, 0, 3, 442, 221, 1315, 0, 3, 48, 24, 1316, 0, 1, 1314, 0, 0, 0, 1, 1316, 0, 0, 0, 1, 133, 0, 0, 0, 3, 136, 68, 1324, 0, 3, 138, 69, 1324, 0, 3, 140, 70, 1324, 0, 3, 142, 71, 1324, 0, 3, 144, 72, 1324, 0, 3, 146, 73, 1324, 0, 1, 1317, 0, 0, 0, 1, 1318, 0, 0, 0, 1, 1319, 0, 0, 0, 1, 1320, 0, 0, 0, 1, 1321, 0, 0, 0, 1, 1322, 0, 0, 0, 1, 135, 0, 0, 0, 3, 10, 5, 1327, 0, 1, 1325, 0, 0, 0, 1, 1330, 0, 0, 0, 1, 1326, 0, 0, 0, 1, 1329, 0, 0, 0, 1, 1334, 0, 0, 0, 1, 1328, 0, 0, 0, 3, 38, 19, 1333, 0, 1, 1331, 0, 0, 0, 1, 1336, 0, 0, 0, 1, 1332, 0, 0, 0, 1, 1335, 0, 0, 0, 1, 1337, 0, 0, 0, 1, 1334, 0, 0, 0, 5, 1338, 64, 0, 0, 3, 442, 221, 1340, 0, 3, 76, 38, 1341, 0, 1, 1339, 0, 0, 0, 1, 1341, 0, 0, 0, 1, 1343, 0, 0, 0, 3, 56, 28, 1344, 0, 1, 1342, 0, 0, 0, 1, 1344, 0, 0, 0, 1, 1346, 0, 0, 0, 3, 124, 62, 1347, 0, 1, 1345, 0, 0, 0, 1, 1347, 0, 0, 0, 1, 1351, 0, 0, 0, 3, 80, 40, 1350, 0, 1, 1348, 0, 0, 0, 1, 1353, 0, 0, 0, 1, 1349, 0, 0, 0, 1, 1352, 0, 0, 0, 1, 1362, 0, 0, 0, 1, 1351, 0, 0, 0, 5, 1358, 197, 0, 0, 3, 32, 16, 1357, 0, 1, 1355, 0, 0, 0, 1, 1360, 0, 0, 0, 1, 1356, 0, 0, 0, 1, 1359, 0, 0, 0, 1, 1361, 0, 0, 0, 1, 1358, 0, 0, 0, 5, 1363, 198, 0, 0, 1, 1354, 0, 0, 0, 1, 1363, 0, 0, 0, 1, 1365, 0, 0, 0, 5, 1366, 167, 0, 0, 1, 1364, 0, 0, 0, 1, 1366, 0, 0, 0, 1, 137, 0, 0, 0, 3, 10, 5, 1369, 0, 1, 1367, 0, 0, 0, 1, 1372, 0, 0, 0, 1, 1368, 0, 0, 0, 1, 1371, 0, 0, 0, 1, 1376, 0, 0, 0, 1, 1370, 0, 0, 0, 3, 38, 19, 1375, 0, 1, 1373, 0, 0, 0, 1, 1378, 0, 0, 0, 1, 1374, 0, 0, 0, 1, 1377, 0, 0, 0, 1, 1379, 0, 0, 0, 1, 1376, 0, 0, 0, 5, 1381, 10, 0, 0, 3, 76, 38, 1382, 0, 1, 1380, 0, 0, 0, 1, 1382, 0, 0, 0, 1, 1384, 0, 0, 0, 3, 56, 28, 1385, 0, 1, 1383, 0, 0, 0, 1, 1385, 0, 0, 0, 1, 1389, 0, 0, 0, 3, 80, 40, 1388, 0, 1, 1386, 0, 0, 0, 1, 1391, 0, 0, 0, 1, 1387, 0, 0, 0, 1, 1390, 0, 0, 0, 1, 1392, 0, 0, 0, 1, 1389, 0, 0, 0, 5, 1396, 197, 0, 0, 3, 32, 16, 1395, 0, 1, 1393, 0, 0, 0, 1, 1398, 0, 0, 0, 1, 1394, 0, 0, 0, 1, 1397, 0, 0, 0, 1, 1399, 0, 0, 0, 1, 1396, 0, 0, 0, 5, 1400, 198, 0, 0, 1, 139, 0, 0, 0, 3, 10, 5, 1403, 0, 1, 1401, 0, 0, 0, 1, 1406, 0, 0, 0, 1, 1402, 0, 0, 0, 1, 1405, 0, 0, 0, 1, 1410, 0, 0, 0, 1, 1404, 0, 0, 0, 3, 38, 19, 1409, 0, 1, 1407, 0, 0, 0, 1, 1412, 0, 0, 0, 1, 1408, 0, 0, 0, 1, 1411, 0, 0, 0, 1, 1413, 0, 0, 0, 1, 1410, 0, 0, 0, 5, 1414, 11, 0, 0, 3, 442, 221, 1416, 0, 3, 76, 38, 1417, 0, 1, 1415, 0, 0, 0, 1, 1417, 0, 0, 0, 1, 1419, 0, 0, 0, 3, 56, 28, 1420, 0, 1, 1418, 0, 0, 0, 1, 1420, 0, 0, 0, 1, 1422, 0, 0, 0, 3, 124, 62, 1423, 0, 1, 1421, 0, 0, 0, 1, 1423, 0, 0, 0, 1, 1427, 0, 0, 0, 3, 80, 40, 1426, 0, 1, 1424, 0, 0, 0, 1, 1429, 0, 0, 0, 1, 1425, 0, 0, 0, 1, 1428, 0, 0, 0, 1, 1438, 0, 0, 0, 1, 1427, 0, 0, 0, 5, 1434, 197, 0, 0, 3, 32, 16, 1433, 0, 1, 1431, 0, 0, 0, 1, 1436, 0, 0, 0, 1, 1432, 0, 0, 0, 1, 1435, 0, 0, 0, 1, 1437, 0, 0, 0, 1, 1434, 0, 0, 0, 5, 1439, 198, 0, 0, 1, 1430, 0, 0, 0, 1, 1439, 0, 0, 0, 1, 1441, 0, 0, 0, 5, 1442, 167, 0, 0, 1, 1440, 0, 0, 0, 1, 1442, 0, 0, 0, 1, 141, 0, 0, 0, 3, 10, 5, 1445, 0, 1, 1443, 0, 0, 0, 1, 1448, 0, 0, 0, 1, 1444, 0, 0, 0, 1, 1447, 0, 0, 0, 1, 1452, 0, 0, 0, 1, 1446, 0, 0, 0, 3, 38, 19, 1451, 0, 1, 1449, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1450, 0, 0, 0, 1, 1453, 0, 0, 0, 1, 1455, 0, 0, 0, 1, 1452, 0, 0, 0, 3, 474, 237, 1457, 0, 7, 1458, 6, 0, 0, 1, 1456, 0, 0, 0, 1, 1458, 0, 0, 0, 1, 1459, 0, 0, 0, 3, 442, 221, 1461, 0, 3, 76, 38, 1462, 0, 1, 1460, 0, 0, 0, 1, 1462, 0, 0, 0, 1, 1464, 0, 0, 0, 3, 56, 28, 1465, 0, 1, 1463, 0, 0, 0, 1, 1465, 0, 0, 0, 1, 1467, 0, 0, 0, 3, 124, 62, 1468, 0, 1, 1466, 0, 0, 0, 1, 1468, 0, 0, 0, 1, 1472, 0, 0, 0, 3, 80, 40, 1471, 0, 1, 1469, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1470, 0, 0, 0, 1, 1473, 0, 0, 0, 1, 1483, 0, 0, 0, 1, 1472, 0, 0, 0, 5, 1479, 197, 0, 0, 3, 32, 16, 1478, 0, 1, 1476, 0, 0, 0, 1, 1481, 0, 0, 0, 1, 1477, 0, 0, 0, 1, 1480, 0, 0, 0, 1, 1482, 0, 0, 0, 1, 1479, 0, 0, 0, 5, 1484, 198, 0, 0, 1, 1475, 0, 0, 0, 1, 1484, 0, 0, 0, 1, 1486, 0, 0, 0, 5, 1487, 167, 0, 0, 1, 1485, 0, 0, 0, 1, 1487, 0, 0, 0, 1, 143, 0, 0, 0, 3, 10, 5, 1490, 0, 1, 1488, 0, 0, 0, 1, 1493, 0, 0, 0, 1, 1489, 0, 0, 0, 1, 1492, 0, 0, 0, 1, 1497, 0, 0, 0, 1, 1491, 0, 0, 0, 3, 38, 19, 1496, 0, 1, 1494, 0, 0, 0, 1, 1499, 0, 0, 0, 1, 1495, 0, 0, 0, 1, 1498, 0, 0, 0, 1, 1500, 0, 0, 0, 1, 1497, 0, 0, 0, 5, 1501, 54, 0, 0, 3, 442, 221, 1503, 0, 3, 76, 38, 1504, 0, 1, 1502, 0, 0, 0, 1, 1504, 0, 0, 0, 1, 1506, 0, 0, 0, 3, 56, 28, 1507, 0, 1, 1505, 0, 0, 0, 1, 1507, 0, 0, 0, 1, 1509, 0, 0, 0, 3, 124, 62, 1510, 0, 1, 1508, 0, 0, 0, 1, 1510, 0, 0, 0, 1, 1514, 0, 0, 0, 3, 80, 40, 1513, 0, 1, 1511, 0, 0, 0, 1, 1516, 0, 0, 0, 1, 1512, 0, 0, 0, 1, 1515, 0, 0, 0, 1, 1525, 0, 0, 0, 1, 1514, 0, 0, 0, 5, 1521, 197, 0, 0, 3, 32, 16, 1520, 0, 1, 1518, 0, 0, 0, 1, 1523, 0, 0, 0, 1, 1519, 0, 0, 0, 1, 1522, 0, 0, 0, 1, 1524, 0, 0, 0, 1, 1521, 0, 0, 0, 5, 1526, 198, 0, 0, 1, 1517, 0, 0, 0, 1, 1526, 0, 0, 0, 1, 1528, 0, 0, 0, 5, 1529, 167, 0, 0, 1, 1527, 0, 0, 0, 1, 1529, 0, 0, 0, 1, 145, 0, 0, 0, 3, 10, 5, 1532, 0, 1, 1530, 0, 0, 0, 1, 1535, 0, 0, 0, 1, 1531, 0, 0, 0, 1, 1534, 0, 0, 0, 1, 1539, 0, 0, 0, 1, 1533, 0, 0, 0, 3, 38, 19, 1538, 0, 1, 1536, 0, 0, 0, 1, 1541, 0, 0, 0, 1, 1537, 0, 0, 0, 1, 1540, 0, 0, 0, 1, 1542, 0, 0, 0, 1, 1539, 0, 0, 0, 5, 1543, 76, 0, 0, 3, 442, 221, 1545, 0, 3, 76, 38, 1546, 0, 1, 1544, 0, 0, 0, 1, 1546, 0, 0, 0, 1, 1548, 0, 0, 0, 3, 56, 28, 1549, 0, 1, 1547, 0, 0, 0, 1, 1549, 0, 0, 0, 1, 1551, 0, 0, 0, 3, 124, 62, 1552, 0, 1, 1550, 0, 0, 0, 1, 1552, 0, 0, 0, 1, 1556, 0, 0, 0, 3, 80, 40, 1555, 0, 1, 1553, 0, 0, 0, 1, 1558, 0, 0, 0, 1, 1554, 0, 0, 0, 1, 1557, 0, 0, 0, 1, 1567, 0, 0, 0, 1, 1556, 0, 0, 0, 5, 1563, 197, 0, 0, 3, 32, 16, 1562, 0, 1, 1560, 0, 0, 0, 1, 1565, 0, 0, 0, 1, 1561, 0, 0, 0, 1, 1564, 0, 0, 0, 1, 1566, 0, 0, 0, 1, 1563, 0, 0, 0, 5, 1568, 198, 0, 0, 1, 1559, 0, 0, 0, 1, 1568, 0, 0, 0, 1, 1570, 0, 0, 0, 5, 1571, 167, 0, 0, 1, 1569, 0, 0, 0, 1, 1571, 0, 0, 0, 1, 147, 0, 0, 0, 3, 10, 5, 1574, 0, 1, 1572, 0, 0, 0, 1, 1577, 0, 0, 0, 1, 1573, 0, 0, 0, 1, 1576, 0, 0, 0, 1, 1581, 0, 0, 0, 1, 1575, 0, 0, 0, 3, 38, 19, 1580, 0, 1, 1578, 0, 0, 0, 1, 1583, 0, 0, 0, 1, 1579, 0, 0, 0, 1, 1582, 0, 0, 0, 1, 1584, 0, 0, 0, 1, 1581, 0, 0, 0, 5, 1585, 18, 0, 0, 3, 152, 76, 1586, 0, 3, 442, 221, 1588, 0, 3, 76, 38, 1589, 0, 1, 1587, 0, 0, 0, 1, 1589, 0, 0, 0, 1, 1590, 0, 0, 0, 3, 56, 28, 1594, 0, 3, 80, 40, 1593, 0, 1, 1591, 0, 0, 0, 1, 1596, 0, 0, 0, 1, 1592, 0, 0, 0, 1, 1595, 0, 0, 0, 1, 1597, 0, 0, 0, 1, 1594, 0, 0, 0, 5, 1598, 167, 0, 0, 1, 149, 0, 0, 0, 3, 10, 5, 1601, 0, 1, 1599, 0, 0, 0, 1, 1604, 0, 0, 0, 1, 1600, 0, 0, 0, 1, 1603, 0, 0, 0, 1, 1608, 0, 0, 0, 1, 1602, 0, 0, 0, 3, 38, 19, 1607, 0, 1, 1605, 0, 0, 0, 1, 1610, 0, 0, 0, 1, 1606, 0, 0, 0, 1, 1609, 0, 0, 0, 1, 1611, 0, 0, 0, 1, 1608, 0, 0, 0, 3, 180, 90, 1612, 0, 1, 151, 0, 0, 0, 6, 1614, 76, 4294967295, 0, 3, 158, 79, 1621, 0, 3, 16, 8, 1621, 0, 3, 170, 85, 1621, 0, 3, 172, 86, 1621, 0, 3, 174, 87, 1621, 0, 3, 176, 88, 1621, 0, 1, 1613, 0, 0, 0, 1, 1615, 0, 0, 0, 1, 1616, 0, 0, 0, 1, 1617, 0, 0, 0, 1, 1618, 0, 0, 0, 1, 1619, 0, 0, 0, 1, 1634, 0, 0, 0, 10, 1624, 9, 0, 0, 3, 156, 78, 1625, 0, 1, 1623, 0, 0, 0, 1, 1626, 0, 0, 0, 1, 1624, 0, 0, 0, 1, 1627, 0, 0, 0, 1, 1633, 0, 0, 0, 10, 1629, 6, 0, 0, 5, 1633, 171, 0, 0, 10, 1631, 5, 0, 0, 5, 1633, 161, 0, 0, 1, 1622, 0, 0, 0, 1, 1628, 0, 0, 0, 1, 1630, 0, 0, 0, 1, 1636, 0, 0, 0, 1, 1632, 0, 0, 0, 1, 1635, 0, 0, 0, 1, 153, 0, 0, 0, 1, 1634, 0, 0, 0, 3, 152, 76, 1639, 0, 3, 156, 78, 1640, 0, 1, 1638, 0, 0, 0, 1, 1641, 0, 0, 0, 1, 1639, 0, 0, 0, 1, 1642, 0, 0, 0, 1, 155, 0, 0, 0, 5, 1656, 202, 0, 0, 3, 296, 148, 1646, 0, 1, 1644, 0, 0, 0, 1, 1646, 0, 0, 0, 1, 1653, 0, 0, 0, 5, 1649, 163, 0, 0, 3, 296, 148, 1650, 0, 1, 1648, 0, 0, 0, 1, 1650, 0, 0, 0, 1, 1652, 0, 0, 0, 1, 1647, 0, 0, 0, 1, 1655, 0, 0, 0, 1, 1651, 0, 0, 0, 1, 1654, 0, 0, 0, 1, 1657, 0, 0, 0, 1, 1653, 0, 0, 0, 1, 1645, 0, 0, 0, 1, 1657, 0, 0, 0, 1, 1658, 0, 0, 0, 5, 1659, 203, 0, 0, 1, 157, 0, 0, 0, 5, 1661, 18, 0, 0, 5, 1663, 161, 0, 0, 3, 160, 80, 1664, 0, 1, 1662, 0, 0, 0, 1, 1664, 0, 0, 0, 1, 1665, 0, 0, 0, 3, 166, 83, 1666, 0, 1, 159, 0, 0, 0, 5, 1669, 32, 0, 0, 3, 162, 81, 1670, 0, 1, 1668, 0, 0, 0, 1, 1670, 0, 0, 0, 1, 1676, 0, 0, 0, 5, 1673, 15, 0, 0, 3, 162, 81, 1674, 0, 1, 1672, 0, 0, 0, 1, 1674, 0, 0, 0, 1, 1676, 0, 0, 0, 1, 1667, 0, 0, 0, 1, 1671, 0, 0, 0, 1, 161, 0, 0, 0, 5, 1678, 202, 0, 0, 3, 164, 82, 1683, 0, 5, 1680, 163, 0, 0, 3, 164, 82, 1682, 0, 1, 1679, 0, 0, 0, 1, 1685, 0, 0, 0, 1, 1681, 0, 0, 0, 1, 1684, 0, 0, 0, 1, 1686, 0, 0, 0, 1, 1683, 0, 0, 0, 5, 1687, 203, 0, 0, 1, 163, 0, 0, 0, 3, 442, 221, 1689, 0, 1, 165, 0, 0, 0, 5, 1691, 168, 0, 0, 3, 168, 84, 1696, 0, 5, 1693, 163, 0, 0, 3, 168, 84, 1695, 0, 1, 1692, 0, 0, 0, 1, 1698, 0, 0, 0, 1, 1694, 0, 0, 0, 1, 1697, 0, 0, 0, 1, 1699, 0, 0, 0, 1, 1696, 0, 0, 0, 5, 1700, 170, 0, 0, 1, 167, 0, 0, 0, 3, 10, 5, 1703, 0, 1, 1701, 0, 0, 0, 1, 1706, 0, 0, 0, 1, 1702, 0, 0, 0, 1, 1705, 0, 0, 0, 1, 1710, 0, 0, 0, 1, 1704, 0, 0, 0, 3, 38, 19, 1709, 0, 1, 1707, 0, 0, 0, 1, 1712, 0, 0, 0, 1, 1708, 0, 0, 0, 1, 1711, 0, 0, 0, 1, 1713, 0, 0, 0, 1, 1710, 0, 0, 0, 3, 152, 76, 1714, 0, 1, 169, 0, 0, 0, 7, 1716, 7, 0, 0, 1, 171, 0, 0, 0, 5, 1719, 116, 0, 0, 5, 1720, 24, 0, 0, 1, 1718, 0, 0, 0, 1, 1720, 0, 0, 0, 1, 1721, 0, 0, 0, 3, 152, 76, 1722, 0, 1, 173, 0, 0, 0, 5, 1724, 48, 0, 0, 3, 152, 76, 1725, 0, 1, 175, 0, 0, 0, 5, 1727, 200, 0, 0, 3, 178, 89, 1730, 0, 5, 1729, 163, 0, 0, 3, 178, 89, 1731, 0, 1, 1728, 0, 0, 0, 1, 1732, 0, 0, 0, 1, 1730, 0, 0, 0, 1, 1733, 0, 0, 0, 1, 1734, 0, 0, 0, 5, 1735, 201, 0, 0, 1, 177, 0, 0, 0, 3, 152, 76, 1738, 0, 3, 442, 221, 1739, 0, 1, 1737, 0, 0, 0, 1, 1739, 0, 0, 0, 1, 179, 0, 0, 0, 3, 64, 32, 1765, 0, 3, 182, 91, 1765, 0, 3, 184, 92, 1765, 0, 3, 186, 93, 1765, 0, 3, 192, 96, 1765, 0, 3, 194, 97, 1765, 0, 3, 196, 98, 1765, 0, 3, 212, 106, 1765, 0, 3, 198, 99, 1765, 0, 3, 200, 100, 1765, 0, 3, 202, 101, 1765, 0, 3, 204, 102, 1765, 0, 3, 206, 103, 1765, 0, 3, 210, 105, 1765, 0, 3, 214, 107, 1765, 0, 3, 216, 108, 1765, 0, 3, 218, 109, 1765, 0, 3, 220, 110, 1765, 0, 3, 276, 138, 1765, 0, 3, 278, 139, 1765, 0, 3, 288, 144, 1765, 0, 3, 290, 145, 1765, 0, 3, 292, 146, 1765, 0, 3, 294, 147, 1765, 0, 1, 1740, 0, 0, 0, 1, 1741, 0, 0, 0, 1, 1742, 0, 0, 0, 1, 1743, 0, 0, 0, 1, 1744, 0, 0, 0, 1, 1745, 0, 0, 0, 1, 1746, 0, 0, 0, 1, 1747, 0, 0, 0, 1, 1748, 0, 0, 0, 1, 1749, 0, 0, 0, 1, 1750, 0, 0, 0, 1, 1751, 0, 0, 0, 1, 1752, 0, 0, 0, 1, 1753, 0, 0, 0, 1, 1754, 0, 0, 0, 1, 1755, 0, 0, 0, 1, 1756, 0, 0, 0, 1, 1757, 0, 0, 0, 1, 1758, 0, 0, 0, 1, 1759, 0, 0, 0, 1, 1760, 0, 0, 0, 1, 1761, 0, 0, 0, 1, 1762, 0, 0, 0, 1, 1763, 0, 0, 0, 1, 181, 0, 0, 0, 3, 10, 5, 1768, 0, 1, 1766, 0, 0, 0, 1, 1771, 0, 0, 0, 1, 1767, 0, 0, 0, 1, 1770, 0, 0, 0, 1, 1772, 0, 0, 0, 1, 1769, 0, 0, 0, 5, 1774, 62, 0, 0, 3, 8, 4, 1775, 0, 1, 1773, 0, 0, 0, 1, 1775, 0, 0, 0, 1, 1776, 0, 0, 0, 5, 1777, 167, 0, 0, 1, 183, 0, 0, 0, 3, 10, 5, 1780, 0, 1, 1778, 0, 0, 0, 1, 1783, 0, 0, 0, 1, 1779, 0, 0, 0, 1, 1782, 0, 0, 0, 1, 1784, 0, 0, 0, 1, 1781, 0, 0, 0, 7, 1785, 8, 0, 0, 3, 64, 32, 1786, 0, 1, 185, 0, 0, 0, 3, 188, 94, 1790, 0, 3, 190, 95, 1790, 0, 1, 1787, 0, 0, 0, 1, 1788, 0, 0, 0, 1, 187, 0, 0, 0, 3, 10, 5, 1793, 0, 1, 1791, 0, 0, 0, 1, 1796, 0, 0, 0, 1, 1792, 0, 0, 0, 1, 1795, 0, 0, 0, 1, 1798, 0, 0, 0, 1, 1794, 0, 0, 0, 5, 1799, 61, 0, 0, 1, 1797, 0, 0, 0, 1, 1799, 0, 0, 0, 1, 1800, 0, 0, 0, 5, 1801, 31, 0, 0, 5, 1802, 200, 0, 0, 3, 152, 76, 1803, 0, 3, 442, 221, 1804, 0, 5, 1805, 149, 0, 0, 3, 296, 148, 1806, 0, 5, 1807, 201, 0, 0, 3, 180, 90, 1808, 0, 1, 189, 0, 0, 0, 3, 10, 5, 1811, 0, 1, 1809, 0, 0, 0, 1, 1814, 0, 0, 0, 1, 1810, 0, 0, 0, 1, 1813, 0, 0, 0, 1, 1816, 0, 0, 0, 1, 1812, 0, 0, 0, 5, 1817, 61, 0, 0, 1, 1815, 0, 0, 0, 1, 1817, 0, 0, 0, 1, 1818, 0, 0, 0, 5, 1819, 31, 0, 0, 5, 1820, 200, 0, 0, 3, 296, 148, 1821, 0, 5, 1822, 149, 0, 0, 3, 296, 148, 1823, 0, 5, 1824, 201, 0, 0, 3, 180, 90, 1825, 0, 1, 191, 0, 0, 0, 3, 10, 5, 1828, 0, 1, 1826, 0, 0, 0, 1, 1831, 0, 0, 0, 1, 1827, 0, 0, 0, 1, 1830, 0, 0, 0, 1, 1832, 0, 0, 0, 1, 1829, 0, 0, 0, 5, 1834, 17, 0, 0, 3, 8, 4, 1835, 0, 1, 1833, 0, 0, 0, 1, 1835, 0, 0, 0, 1, 1836, 0, 0, 0, 5, 1837, 167, 0, 0, 1, 193, 0, 0, 0, 3, 10, 5, 1840, 0, 1, 1838, 0, 0, 0, 1, 1843, 0, 0, 0, 1, 1839, 0, 0, 0, 1, 1842, 0, 0, 0, 1, 1844, 0, 0, 0, 1, 1841, 0, 0, 0, 5, 1845, 147, 0, 0, 3, 180, 90, 1846, 0, 5, 1847, 79, 0, 0, 5, 1848, 200, 0, 0, 3, 296, 148, 1849, 0, 5, 1850, 201, 0, 0, 5, 1851, 167, 0, 0, 1, 195, 0, 0, 0, 3, 10, 5, 1854, 0, 1, 1852, 0, 0, 0, 1, 1857, 0, 0, 0, 1, 1853, 0, 0, 0, 1, 1856, 0, 0, 0, 1, 1858, 0, 0, 0, 1, 1855, 0, 0, 0, 5, 1859, 167, 0, 0, 1, 197, 0, 0, 0, 3, 10, 5, 1862, 0, 1, 1860, 0, 0, 0, 1, 1865, 0, 0, 0, 1, 1861, 0, 0, 0, 1, 1864, 0, 0, 0, 1, 1866, 0, 0, 0, 1, 1863, 0, 0, 0, 3, 296, 148, 1867, 0, 5, 1868, 167, 0, 0, 1, 199, 0, 0, 0, 3, 10, 5, 1871, 0, 1, 1869, 0, 0, 0, 1, 1874, 0, 0, 0, 1, 1870, 0, 0, 0, 1, 1873, 0, 0, 0, 1, 1875, 0, 0, 0, 1, 1872, 0, 0, 0, 5, 1876, 69, 0, 0, 5, 1877, 200, 0, 0, 3, 40, 20, 1878, 0, 5, 1879, 201, 0, 0, 3, 180, 90, 1880, 0, 1, 201, 0, 0, 0, 3, 10, 5, 1883, 0, 1, 1881, 0, 0, 0, 1, 1886, 0, 0, 0, 1, 1882, 0, 0, 0, 1, 1885, 0, 0, 0, 1, 1887, 0, 0, 0, 1, 1884, 0, 0, 0, 5, 1888, 109, 0, 0, 5, 1902, 200, 0, 0, 3, 40, 20, 1891, 0, 1, 1889, 0, 0, 0, 1, 1891, 0, 0, 0, 1, 1903, 0, 0, 0, 3, 296, 148, 1897, 0, 5, 1894, 163, 0, 0, 3, 296, 148, 1896, 0, 1, 1893, 0, 0, 0, 1, 1899, 0, 0, 0, 1, 1895, 0, 0, 0, 1, 1898, 0, 0, 0, 1, 1901, 0, 0, 0, 1, 1897, 0, 0, 0, 1, 1892, 0, 0, 0, 1, 1901, 0, 0, 0, 1, 1903, 0, 0, 0, 1, 1890, 0, 0, 0, 1, 1900, 0, 0, 0, 1, 1904, 0, 0, 0, 5, 1906, 167, 0, 0, 3, 296, 148, 1907, 0, 1, 1905, 0, 0, 0, 1, 1907, 0, 0, 0, 1, 1908, 0, 0, 0, 5, 1917, 167, 0, 0, 3, 296, 148, 1914, 0, 5, 1911, 163, 0, 0, 3, 296, 148, 1913, 0, 1, 1910, 0, 0, 0, 1, 1916, 0, 0, 0, 1, 1912, 0, 0, 0, 1, 1915, 0, 0, 0, 1, 1918, 0, 0, 0, 1, 1914, 0, 0, 0, 1, 1909, 0, 0, 0, 1, 1918, 0, 0, 0, 1, 1919, 0, 0, 0, 5, 1920, 201, 0, 0, 3, 180, 90, 1921, 0, 1, 203, 0, 0, 0, 3, 10, 5, 1924, 0, 1, 1922, 0, 0, 0, 1, 1927, 0, 0, 0, 1, 1923, 0, 0, 0, 1, 1926, 0, 0, 0, 1, 1928, 0, 0, 0, 1, 1925, 0, 0, 0, 5, 1930, 90, 0, 0, 7, 1931, 9, 0, 0, 1, 1929, 0, 0, 0, 1, 1931, 0, 0, 0, 1, 1933, 0, 0, 0, 3, 296, 148, 1934, 0, 1, 1932, 0, 0, 0, 1, 1934, 0, 0, 0, 1, 1935, 0, 0, 0, 5, 1936, 167, 0, 0, 1, 205, 0, 0, 0, 3, 10, 5, 1939, 0, 1, 1937, 0, 0, 0, 1, 1942, 0, 0, 0, 1, 1938, 0, 0, 0, 1, 1941, 0, 0, 0, 1, 1943, 0, 0, 0, 1, 1940, 0, 0, 0, 5, 1944, 148, 0, 0, 5, 1945, 200, 0, 0, 3, 296, 148, 1946, 0, 5, 1947, 201, 0, 0, 3, 180, 90, 1949, 0, 3, 208, 104, 1950, 0, 1, 1948, 0, 0, 0, 1, 1950, 0, 0, 0, 1, 207, 0, 0, 0, 5, 1952, 86, 0, 0, 3, 180, 90, 1953, 0, 1, 209, 0, 0, 0, 3, 10, 5, 1956, 0, 1, 1954, 0, 0, 0, 1, 1959, 0, 0, 0, 1, 1955, 0, 0, 0, 1, 1958, 0, 0, 0, 1, 1960, 0, 0, 0, 1, 1957, 0, 0, 0, 3, 442, 221, 1961, 0, 5, 1962, 199, 0, 0, 3, 180, 90, 1963, 0, 1, 211, 0, 0, 0, 3, 10, 5, 1966, 0, 1, 1964, 0, 0, 0, 1, 1969, 0, 0, 0, 1, 1965, 0, 0, 0, 1, 1968, 0, 0, 0, 1, 1971, 0, 0, 0, 1, 1967, 0, 0, 0, 5, 1972, 61, 0, 0, 1, 1970, 0, 0, 0, 1, 1972, 0, 0, 0, 1, 1974, 0, 0, 0, 5, 1975, 77, 0, 0, 1, 1973, 0, 0, 0, 1, 1975, 0, 0, 0, 1, 1979, 0, 0, 0, 3, 38, 19, 1978, 0, 1, 1976, 0, 0, 0, 1, 1981, 0, 0, 0, 1, 1977, 0, 0, 0, 1, 1980, 0, 0, 0, 1, 1982, 0, 0, 0, 1, 1979, 0, 0, 0, 3, 484, 242, 1983, 0, 5, 1984, 167, 0, 0, 1, 213, 0, 0, 0, 3, 10, 5, 1987, 0, 1, 1985, 0, 0, 0, 1, 1990, 0, 0, 0, 1, 1986, 0, 0, 0, 1, 1989, 0, 0, 0, 1, 1994, 0, 0, 0, 1, 1988, 0, 0, 0, 3, 38, 19, 1993, 0, 1, 1991, 0, 0, 0, 1, 1996, 0, 0, 0, 1, 1992, 0, 0, 0, 1, 1995, 0, 0, 0, 1, 1997, 0, 0, 0, 1, 1994, 0, 0, 0, 3, 152, 76, 1998, 0, 3, 442, 221, 2000, 0, 3, 76, 38, 2001, 0, 1, 1999, 0, 0, 0, 1, 2001, 0, 0, 0, 1, 2002, 0, 0, 0, 3, 56, 28, 2006, 0, 3, 80, 40, 2005, 0, 1, 2003, 0, 0, 0, 1, 2008, 0, 0, 0, 1, 2004, 0, 0, 0, 1, 2007, 0, 0, 0, 1, 2013, 0, 0, 0, 1, 2006, 0, 0, 0, 3, 64, 32, 2014, 0, 3, 66, 33, 2011, 0, 5, 2012, 167, 0, 0, 1, 2014, 0, 0, 0, 1, 2009, 0, 0, 0, 1, 2010, 0, 0, 0, 1, 215, 0, 0, 0, 3, 10, 5, 2017, 0, 1, 2015, 0, 0, 0, 1, 2020, 0, 0, 0, 1, 2016, 0, 0, 0, 1, 2019, 0, 0, 0, 1, 2021, 0, 0, 0, 1, 2018, 0, 0, 0, 5, 2022, 94, 0, 0, 5, 2023, 200, 0, 0, 3, 296, 148, 2024, 0, 5, 2025, 201, 0, 0, 3, 180, 90, 2026, 0, 1, 217, 0, 0, 0, 3, 10, 5, 2029, 0, 1, 2027, 0, 0, 0, 1, 2032, 0, 0, 0, 1, 2028, 0, 0, 0, 1, 2031, 0, 0, 0, 1, 2033, 0, 0, 0, 1, 2030, 0, 0, 0, 5, 2035, 47, 0, 0, 3, 296, 148, 2036, 0, 1, 2034, 0, 0, 0, 1, 2036, 0, 0, 0, 1, 2037, 0, 0, 0, 5, 2038, 167, 0, 0, 1, 219, 0, 0, 0, 3, 10, 5, 2041, 0, 1, 2039, 0, 0, 0, 1, 2044, 0, 0, 0, 1, 2040, 0, 0, 0, 1, 2043, 0, 0, 0, 1, 2045, 0, 0, 0, 1, 2042, 0, 0, 0, 5, 2046, 55, 0, 0, 5, 2047, 200, 0, 0, 3, 296, 148, 2048, 0, 5, 2049, 201, 0, 0, 5, 2053, 197, 0, 0, 3, 222, 111, 2052, 0, 1, 2050, 0, 0, 0, 1, 2055, 0, 0, 0, 1, 2051, 0, 0, 0, 1, 2054, 0, 0, 0, 1, 2056, 0, 0, 0, 1, 2053, 0, 0, 0, 5, 2057, 198, 0, 0, 1, 221, 0, 0, 0, 3, 224, 112, 2060, 0, 1, 2058, 0, 0, 0, 1, 2061, 0, 0, 0, 1, 2059, 0, 0, 0, 1, 2062, 0, 0, 0, 1, 2064, 0, 0, 0, 3, 180, 90, 2065, 0, 1, 2063, 0, 0, 0, 1, 2066, 0, 0, 0, 1, 2064, 0, 0, 0, 1, 2067, 0, 0, 0, 1, 223, 0, 0, 0, 3, 226, 113, 2072, 0, 3, 272, 136, 2072, 0, 3, 274, 137, 2072, 0, 1, 2068, 0, 0, 0, 1, 2069, 0, 0, 0, 1, 2070, 0, 0, 0, 1, 225, 0, 0, 0, 5, 2074, 84, 0, 0, 3, 228, 114, 2076, 0, 3, 270, 135, 2077, 0, 1, 2075, 0, 0, 0, 1, 2077, 0, 0, 0, 1, 2078, 0, 0, 0, 5, 2079, 199, 0, 0, 1, 227, 0, 0, 0, 6, 2081, 114, 4294967295, 0, 3, 268, 134, 2093, 0, 3, 230, 115, 2093, 0, 3, 232, 116, 2093, 0, 3, 242, 121, 2093, 0, 3, 244, 122, 2093, 0, 3, 246, 123, 2093, 0, 3, 248, 124, 2093, 0, 3, 260, 130, 2093, 0, 3, 262, 131, 2093, 0, 3, 264, 132, 2093, 0, 3, 266, 133, 2093, 0, 1, 2080, 0, 0, 0, 1, 2082, 0, 0, 0, 1, 2083, 0, 0, 0, 1, 2084, 0, 0, 0, 1, 2085, 0, 0, 0, 1, 2086, 0, 0, 0, 1, 2087, 0, 0, 0, 1, 2088, 0, 0, 0, 1, 2089, 0, 0, 0, 1, 2090, 0, 0, 0, 1, 2091, 0, 0, 0, 1, 2099, 0, 0, 0, 10, 2095, 12, 0, 0, 7, 2096, 10, 0, 0, 3, 228, 114, 2098, 13, 1, 2094, 0, 0, 0, 1, 2101, 0, 0, 0, 1, 2097, 0, 0, 0, 1, 2100, 0, 0, 0, 1, 229, 0, 0, 0, 1, 2099, 0, 0, 0, 3, 296, 148, 2103, 0, 1, 231, 0, 0, 0, 3, 152, 76, 2105, 0, 3, 234, 117, 2106, 0, 1, 233, 0, 0, 0, 3, 236, 118, 2111, 0, 3, 238, 119, 2111, 0, 3, 240, 120, 2111, 0, 1, 2107, 0, 0, 0, 1, 2108, 0, 0, 0, 1, 2109, 0, 0, 0, 1, 235, 0, 0, 0, 5, 2113, 173, 0, 0, 1, 237, 0, 0, 0, 5, 2123, 200, 0, 0, 3, 234, 117, 2120, 0, 5, 2117, 163, 0, 0, 3, 234, 117, 2119, 0, 1, 2116, 0, 0, 0, 1, 2122, 0, 0, 0, 1, 2118, 0, 0, 0, 1, 2121, 0, 0, 0, 1, 2124, 0, 0, 0, 1, 2120, 0, 0, 0, 1, 2115, 0, 0, 0, 1, 2124, 0, 0, 0, 1, 2125, 0, 0, 0, 5, 2126, 201, 0, 0, 1, 239, 0, 0, 0, 7, 2128, 11, 0, 0, 1, 241, 0, 0, 0, 5, 2130, 173, 0, 0, 1, 243, 0, 0, 0, 5, 2143, 202, 0, 0, 3, 228, 114, 2137, 0, 5, 2134, 163, 0, 0, 3, 228, 114, 2136, 0, 1, 2133, 0, 0, 0, 1, 2139, 0, 0, 0, 1, 2135, 0, 0, 0, 1, 2138, 0, 0, 0, 1, 2141, 0, 0, 0, 1, 2137, 0, 0, 0, 5, 2142, 163, 0, 0, 1, 2140, 0, 0, 0, 1, 2142, 0, 0, 0, 1, 2144, 0, 0, 0, 1, 2132, 0, 0, 0, 1, 2144, 0, 0, 0, 1, 2145, 0, 0, 0, 5, 2147, 203, 0, 0, 3, 234, 117, 2148, 0, 1, 2146, 0, 0, 0, 1, 2148, 0, 0, 0, 1, 245, 0, 0, 0, 5, 2150, 200, 0, 0, 3, 228, 114, 2151, 0, 5, 2152, 201, 0, 0, 1, 247, 0, 0, 0, 3, 152, 76, 2155, 0, 1, 2153, 0, 0, 0, 1, 2155, 0, 0, 0, 1, 2157, 0, 0, 0, 3, 250, 125, 2158, 0, 1, 2156, 0, 0, 0, 1, 2158, 0, 0, 0, 1, 2160, 0, 0, 0, 3, 258, 129, 2161, 0, 1, 2159, 0, 0, 0, 1, 2161, 0, 0, 0, 1, 2163, 0, 0, 0, 3, 234, 117, 2164, 0, 1, 2162, 0, 0, 0, 1, 2164, 0, 0, 0, 1, 249, 0, 0, 0, 5, 2174, 200, 0, 0, 3, 252, 126, 2171, 0, 5, 2168, 163, 0, 0, 3, 252, 126, 2170, 0, 1, 2167, 0, 0, 0, 1, 2173, 0, 0, 0, 1, 2169, 0, 0, 0, 1, 2172, 0, 0, 0, 1, 2175, 0, 0, 0, 1, 2171, 0, 0, 0, 1, 2166, 0, 0, 0, 1, 2175, 0, 0, 0, 1, 2176, 0, 0, 0, 5, 2177, 201, 0, 0, 1, 251, 0, 0, 0, 3, 254, 127, 2180, 0, 1, 2178, 0, 0, 0, 1, 2180, 0, 0, 0, 1, 2181, 0, 0, 0, 3, 228, 114, 2182, 0, 1, 253, 0, 0, 0, 3, 256, 128, 2186, 0, 3, 30, 15, 2186, 0, 1, 2183, 0, 0, 0, 1, 2184, 0, 0, 0, 1, 255, 0, 0, 0, 3, 296, 148, 2188, 0, 5, 2189, 199, 0, 0, 1, 257, 0, 0, 0, 5, 2202, 197, 0, 0, 3, 252, 126, 2196, 0, 5, 2193, 163, 0, 0, 3, 252, 126, 2195, 0, 1, 2192, 0, 0, 0, 1, 2198, 0, 0, 0, 1, 2194, 0, 0, 0, 1, 2197, 0, 0, 0, 1, 2200, 0, 0, 0, 1, 2196, 0, 0, 0, 5, 2201, 163, 0, 0, 1, 2199, 0, 0, 0, 1, 2201, 0, 0, 0, 1, 2203, 0, 0, 0, 1, 2191, 0, 0, 0, 1, 2203, 0, 0, 0, 1, 2204, 0, 0, 0, 5, 2205, 198, 0, 0, 1, 259, 0, 0, 0, 5, 2207, 120, 0, 0, 3, 296, 148, 2219, 0, 5, 2209, 168, 0, 0, 3, 296, 148, 2219, 0, 5, 2211, 136, 0, 0, 3, 296, 148, 2219, 0, 5, 2213, 137, 0, 0, 3, 296, 148, 2219, 0, 5, 2215, 170, 0, 0, 3, 296, 148, 2219, 0, 5, 2217, 139, 0, 0, 3, 296, 148, 2219, 0, 1, 2206, 0, 0, 0, 1, 2208, 0, 0, 0, 1, 2210, 0, 0, 0, 1, 2212, 0, 0, 0, 1, 2214, 0, 0, 0, 1, 2216, 0, 0, 0, 1, 261, 0, 0, 0, 5, 2222, 130, 0, 0, 3, 228, 114, 2223, 0, 1, 2221, 0, 0, 0, 1, 2223, 0, 0, 0, 1, 263, 0, 0, 0, 3, 152, 76, 2225, 0, 1, 265, 0, 0, 0, 5, 2227, 114, 0, 0, 3, 228, 114, 2228, 0, 1, 267, 0, 0, 0, 5, 2230, 119, 0, 0, 3, 234, 117, 2231, 0, 1, 269, 0, 0, 0, 5, 2233, 102, 0, 0, 3, 296, 148, 2234, 0, 1, 271, 0, 0, 0, 5, 2236, 84, 0, 0, 3, 296, 148, 2237, 0, 5, 2238, 199, 0, 0, 1, 273, 0, 0, 0, 5, 2240, 29, 0, 0, 5, 2241, 199, 0, 0, 1, 275, 0, 0, 0, 3, 10, 5, 2244, 0, 1, 2242, 0, 0, 0, 1, 2247, 0, 0, 0, 1, 2243, 0, 0, 0, 1, 2246, 0, 0, 0, 1, 2248, 0, 0, 0, 1, 2245, 0, 0, 0, 5, 2250, 74, 0, 0, 3, 296, 148, 2251, 0, 1, 2249, 0, 0, 0, 1, 2251, 0, 0, 0, 1, 2252, 0, 0, 0, 5, 2253, 167, 0, 0, 1, 277, 0, 0, 0, 3, 10, 5, 2256, 0, 1, 2254, 0, 0, 0, 1, 2259, 0, 0, 0, 1, 2255, 0, 0, 0, 1, 2258, 0, 0, 0, 1, 2260, 0, 0, 0, 1, 2257, 0, 0, 0, 5, 2261, 118, 0, 0, 3, 64, 32, 2265, 0, 3, 280, 140, 2264, 0, 1, 2262, 0, 0, 0, 1, 2267, 0, 0, 0, 1, 2263, 0, 0, 0, 1, 2266, 0, 0, 0, 1, 2269, 0, 0, 0, 1, 2265, 0, 0, 0, 3, 286, 143, 2270, 0, 1, 2268, 0, 0, 0, 1, 2270, 0, 0, 0, 1, 279, 0, 0, 0, 5, 2273, 63, 0, 0, 3, 282, 141, 2274, 0, 1, 2272, 0, 0, 0, 1, 2274, 0, 0, 0, 1, 2276, 0, 0, 0, 3, 284, 142, 2277, 0, 1, 2275, 0, 0, 0, 1, 2277, 0, 0, 0, 1, 2278, 0, 0, 0, 3, 64, 32, 2279, 0, 1, 281, 0, 0, 0, 5, 2281, 200, 0, 0, 3, 152, 76, 2283, 0, 3, 442, 221, 2284, 0, 1, 2282, 0, 0, 0, 1, 2284, 0, 0, 0, 1, 2285, 0, 0, 0, 5, 2286, 201, 0, 0, 1, 283, 0, 0, 0, 5, 2288, 102, 0, 0, 5, 2289, 200, 0, 0, 3, 296, 148, 2290, 0, 5, 2291, 201, 0, 0, 1, 285, 0, 0, 0, 5, 2293, 30, 0, 0, 3, 64, 32, 2294, 0, 1, 287, 0, 0, 0, 3, 10, 5, 2297, 0, 1, 2295, 0, 0, 0, 1, 2300, 0, 0, 0, 1, 2296, 0, 0, 0, 1, 2299, 0, 0, 0, 1, 2301, 0, 0, 0, 1, 2298, 0, 0, 0, 5, 2302, 57, 0, 0, 3, 64, 32, 2303, 0, 1, 289, 0, 0, 0, 3, 10, 5, 2306, 0, 1, 2304, 0, 0, 0, 1, 2309, 0, 0, 0, 1, 2305, 0, 0, 0, 1, 2308, 0, 0, 0, 1, 2311, 0, 0, 0, 1, 2307, 0, 0, 0, 5, 2312, 61, 0, 0, 1, 2310, 0, 0, 0, 1, 2312, 0, 0, 0, 1, 2313, 0, 0, 0, 5, 2314, 77, 0, 0, 5, 2317, 200, 0, 0, 3, 40, 20, 2318, 0, 3, 296, 148, 2318, 0, 1, 2315, 0, 0, 0, 1, 2316, 0, 0, 0, 1, 2319, 0, 0, 0, 5, 2320, 201, 0, 0, 3, 180, 90, 2321, 0, 1, 291, 0, 0, 0, 3, 10, 5, 2324, 0, 1, 2322, 0, 0, 0, 1, 2327, 0, 0, 0, 1, 2323, 0, 0, 0, 1, 2326, 0, 0, 0, 1, 2328, 0, 0, 0, 1, 2325, 0, 0, 0, 5, 2329, 79, 0, 0, 5, 2330, 200, 0, 0, 3, 296, 148, 2331, 0, 5, 2332, 201, 0, 0, 3, 180, 90, 2333, 0, 1, 293, 0, 0, 0, 3, 10, 5, 2336, 0, 1, 2334, 0, 0, 0, 1, 2339, 0, 0, 0, 1, 2335, 0, 0, 0, 1, 2338, 0, 0, 0, 1, 2340, 0, 0, 0, 1, 2337, 0, 0, 0, 5, 2341, 80, 0, 0, 7, 2343, 12, 0, 0, 3, 296, 148, 2344, 0, 1, 2342, 0, 0, 0, 1, 2344, 0, 0, 0, 1, 2345, 0, 0, 0, 5, 2346, 167, 0, 0, 1, 295, 0, 0, 0, 6, 2348, 148, 4294967295, 0, 3, 298, 149, 2387, 0, 3, 308, 154, 2387, 0, 3, 312, 156, 2387, 0, 3, 316, 158, 2387, 0, 3, 318, 159, 2387, 0, 3, 324, 162, 2387, 0, 3, 326, 163, 2387, 0, 3, 328, 164, 2387, 0, 3, 340, 170, 2387, 0, 3, 342, 171, 2387, 0, 3, 344, 172, 2387, 0, 3, 346, 173, 2387, 0, 3, 348, 174, 2387, 0, 3, 350, 175, 2387, 0, 3, 314, 157, 2387, 0, 3, 352, 176, 2387, 0, 3, 358, 179, 2387, 0, 3, 376, 188, 2387, 0, 3, 384, 192, 2387, 0, 3, 386, 193, 2387, 0, 3, 388, 194, 2387, 0, 3, 390, 195, 2387, 0, 3, 392, 196, 2387, 0, 5, 2373, 130, 0, 0, 3, 296, 148, 2374, 0, 1, 2372, 0, 0, 0, 1, 2374, 0, 0, 0, 1, 2387, 0, 0, 0, 3, 420, 210, 2387, 0, 3, 422, 211, 2387, 0, 3, 424, 212, 2387, 0, 3, 426, 213, 2387, 0, 3, 428, 214, 2387, 0, 3, 432, 216, 2387, 0, 3, 434, 217, 2387, 0, 3, 152, 76, 2387, 0, 3, 436, 218, 2387, 0, 3, 438, 219, 2387, 0, 3, 338, 169, 2387, 0, 1, 2347, 0, 0, 0, 1, 2349, 0, 0, 0, 1, 2350, 0, 0, 0, 1, 2351, 0, 0, 0, 1, 2352, 0, 0, 0, 1, 2353, 0, 0, 0, 1, 2354, 0, 0, 0, 1, 2355, 0, 0, 0, 1, 2356, 0, 0, 0, 1, 2357, 0, 0, 0, 1, 2358, 0, 0, 0, 1, 2359, 0, 0, 0, 1, 2360, 0, 0, 0, 1, 2361, 0, 0, 0, 1, 2362, 0, 0, 0, 1, 2363, 0, 0, 0, 1, 2364, 0, 0, 0, 1, 2365, 0, 0, 0, 1, 2366, 0, 0, 0, 1, 2367, 0, 0, 0, 1, 2368, 0, 0, 0, 1, 2369, 0, 0, 0, 1, 2370, 0, 0, 0, 1, 2371, 0, 0, 0, 1, 2375, 0, 0, 0, 1, 2376, 0, 0, 0, 1, 2377, 0, 0, 0, 1, 2378, 0, 0, 0, 1, 2379, 0, 0, 0, 1, 2380, 0, 0, 0, 1, 2381, 0, 0, 0, 1, 2382, 0, 0, 0, 1, 2383, 0, 0, 0, 1, 2384, 0, 0, 0, 1, 2385, 0, 0, 0, 1, 2479, 0, 0, 0, 10, 2402, 44, 0, 0, 5, 2403, 169, 0, 0, 5, 2403, 126, 0, 0, 5, 2403, 128, 0, 0, 5, 2403, 124, 0, 0, 5, 2403, 131, 0, 0, 5, 2403, 121, 0, 0, 5, 2403, 123, 0, 0, 5, 2403, 144, 0, 0, 5, 2403, 154, 0, 0, 5, 2403, 105, 0, 0, 3, 480, 240, 2403, 0, 3, 482, 241, 2403, 0, 5, 2403, 106, 0, 0, 1, 2389, 0, 0, 0, 1, 2390, 0, 0, 0, 1, 2391, 0, 0, 0, 1, 2392, 0, 0, 0, 1, 2393, 0, 0, 0, 1, 2394, 0, 0, 0, 1, 2395, 0, 0, 0, 1, 2396, 0, 0, 0, 1, 2397, 0, 0, 0, 1, 2398, 0, 0, 0, 1, 2399, 0, 0, 0, 1, 2400, 0, 0, 0, 1, 2401, 0, 0, 0, 1, 2404, 0, 0, 0, 3, 296, 148, 2478, 45, 10, 2428, 41, 0, 0, 5, 2429, 162, 0, 0, 5, 2429, 164, 0, 0, 5, 2429, 161, 0, 0, 5, 2429, 166, 0, 0, 5, 2429, 159, 0, 0, 5, 2429, 135, 0, 0, 3, 476, 238, 2429, 0, 3, 478, 239, 2429, 0, 5, 2429, 155, 0, 0, 5, 2429, 122, 0, 0, 5, 2429, 174, 0, 0, 5, 2429, 160, 0, 0, 5, 2429, 172, 0, 0, 5, 2429, 137, 0, 0, 5, 2429, 120, 0, 0, 5, 2429, 168, 0, 0, 5, 2429, 136, 0, 0, 5, 2429, 170, 0, 0, 5, 2429, 139, 0, 0, 5, 2429, 150, 0, 0, 5, 2429, 145, 0, 0, 5, 2429, 140, 0, 0, 1, 2406, 0, 0, 0, 1, 2407, 0, 0, 0, 1, 2408, 0, 0, 0, 1, 2409, 0, 0, 0, 1, 2410, 0, 0, 0, 1, 2411, 0, 0, 0, 1, 2412, 0, 0, 0, 1, 2413, 0, 0, 0, 1, 2414, 0, 0, 0, 1, 2415, 0, 0, 0, 1, 2416, 0, 0, 0, 1, 2417, 0, 0, 0, 1, 2418, 0, 0, 0, 1, 2419, 0, 0, 0, 1, 2420, 0, 0, 0, 1, 2421, 0, 0, 0, 1, 2422, 0, 0, 0, 1, 2423, 0, 0, 0, 1, 2424, 0, 0, 0, 1, 2425, 0, 0, 0, 1, 2426, 0, 0, 0, 1, 2427, 0, 0, 0, 1, 2430, 0, 0, 0, 3, 296, 148, 2478, 42, 10, 2432, 37, 0, 0, 5, 2433, 171, 0, 0, 3, 296, 148, 2478, 38, 10, 2435, 36, 0, 0, 5, 2436, 171, 0, 0, 3, 296, 148, 2437, 0, 5, 2438, 199, 0, 0, 3, 296, 148, 2439, 37, 1, 2478, 0, 0, 0, 10, 2441, 34, 0, 0, 3, 44, 22, 2478, 0, 10, 2443, 25, 0, 0, 3, 62, 31, 2478, 0, 10, 2445, 24, 0, 0, 5, 2446, 150, 0, 0, 3, 228, 114, 2478, 0, 10, 2448, 21, 0, 0, 7, 2449, 13, 0, 0, 3, 20, 10, 2478, 0, 10, 2451, 18, 0, 0, 7, 2478, 14, 0, 0, 10, 2453, 15, 0, 0, 5, 2455, 130, 0, 0, 3, 296, 148, 2456, 0, 1, 2454, 0, 0, 0, 1, 2456, 0, 0, 0, 1, 2478, 0, 0, 0, 10, 2458, 8, 0, 0, 5, 2459, 55, 0, 0, 5, 2471, 197, 0, 0, 3, 430, 215, 2465, 0, 5, 2462, 163, 0, 0, 3, 430, 215, 2464, 0, 1, 2461, 0, 0, 0, 1, 2467, 0, 0, 0, 1, 2463, 0, 0, 0, 1, 2466, 0, 0, 0, 1, 2469, 0, 0, 0, 1, 2465, 0, 0, 0, 5, 2470, 163, 0, 0, 1, 2468, 0, 0, 0, 1, 2470, 0, 0, 0, 1, 2472, 0, 0, 0, 1, 2460, 0, 0, 0, 1, 2472, 0, 0, 0, 1, 2473, 0, 0, 0, 5, 2478, 198, 0, 0, 10, 2475, 2, 0, 0, 5, 2476, 103, 0, 0, 3, 314, 157, 2478, 0, 1, 2388, 0, 0, 0, 1, 2405, 0, 0, 0, 1, 2431, 0, 0, 0, 1, 2434, 0, 0, 0, 1, 2440, 0, 0, 0, 1, 2442, 0, 0, 0, 1, 2444, 0, 0, 0, 1, 2447, 0, 0, 0, 1, 2450, 0, 0, 0, 1, 2452, 0, 0, 0, 1, 2457, 0, 0, 0, 1, 2474, 0, 0, 0, 1, 2481, 0, 0, 0, 1, 2477, 0, 0, 0, 1, 2480, 0, 0, 0, 1, 297, 0, 0, 0, 1, 2479, 0, 0, 0, 3, 300, 150, 2485, 0, 3, 302, 151, 2485, 0, 1, 2482, 0, 0, 0, 1, 2483, 0, 0, 0, 1, 299, 0, 0, 0, 3, 38, 19, 2488, 0, 1, 2486, 0, 0, 0, 1, 2491, 0, 0, 0, 1, 2487, 0, 0, 0, 1, 2490, 0, 0, 0, 1, 2492, 0, 0, 0, 1, 2489, 0, 0, 0, 5, 2494, 18, 0, 0, 3, 56, 28, 2495, 0, 1, 2493, 0, 0, 0, 1, 2495, 0, 0, 0, 1, 2496, 0, 0, 0, 3, 64, 32, 2498, 0, 3, 296, 148, 2499, 0, 1, 2497, 0, 0, 0, 1, 2499, 0, 0, 0, 1, 301, 0, 0, 0, 3, 304, 152, 2503, 0, 3, 306, 153, 2503, 0, 1, 2500, 0, 0, 0, 1, 2501, 0, 0, 0, 1, 303, 0, 0, 0, 3, 10, 5, 2506, 0, 1, 2504, 0, 0, 0, 1, 2509, 0, 0, 0, 1, 2505, 0, 0, 0, 1, 2508, 0, 0, 0, 1, 2513, 0, 0, 0, 1, 2507, 0, 0, 0, 3, 38, 19, 2512, 0, 1, 2510, 0, 0, 0, 1, 2515, 0, 0, 0, 1, 2511, 0, 0, 0, 1, 2514, 0, 0, 0, 1, 2517, 0, 0, 0, 1, 2513, 0, 0, 0, 3, 152, 76, 2518, 0, 1, 2516, 0, 0, 0, 1, 2518, 0, 0, 0, 1, 2519, 0, 0, 0, 3, 56, 28, 2520, 0, 5, 2523, 138, 0, 0, 3, 64, 32, 2524, 0, 3, 296, 148, 2524, 0, 1, 2521, 0, 0, 0, 1, 2522, 0, 0, 0, 1, 305, 0, 0, 0, 3, 10, 5, 2527, 0, 1, 2525, 0, 0, 0, 1, 2530, 0, 0, 0, 1, 2526, 0, 0, 0, 1, 2529, 0, 0, 0, 1, 2534, 0, 0, 0, 1, 2528, 0, 0, 0, 3, 38, 19, 2533, 0, 1, 2531, 0, 0, 0, 1, 2536, 0, 0, 0, 1, 2532, 0, 0, 0, 1, 2535, 0, 0, 0, 1, 2537, 0, 0, 0, 1, 2534, 0, 0, 0, 3, 442, 221, 2538, 0, 5, 2541, 138, 0, 0, 3, 64, 32, 2542, 0, 3, 296, 148, 2542, 0, 1, 2539, 0, 0, 0, 1, 2540, 0, 0, 0, 1, 307, 0, 0, 0, 5, 2544, 113, 0, 0, 5, 2556, 197, 0, 0, 3, 310, 155, 2550, 0, 5, 2547, 163, 0, 0, 3, 310, 155, 2549, 0, 1, 2546, 0, 0, 0, 1, 2552, 0, 0, 0, 1, 2548, 0, 0, 0, 1, 2551, 0, 0, 0, 1, 2554, 0, 0, 0, 1, 2550, 0, 0, 0, 5, 2555, 163, 0, 0, 1, 2553, 0, 0, 0, 1, 2555, 0, 0, 0, 1, 2557, 0, 0, 0, 1, 2545, 0, 0, 0, 1, 2557, 0, 0, 0, 1, 2558, 0, 0, 0, 5, 2559, 198, 0, 0, 1, 309, 0, 0, 0, 3, 6, 3, 2562, 0, 1, 2560, 0, 0, 0, 1, 2562, 0, 0, 0, 1, 2563, 0, 0, 0, 3, 296, 148, 2564, 0, 1, 311, 0, 0, 0, 5, 2566, 113, 0, 0, 3, 154, 77, 2568, 0, 3, 314, 157, 2569, 0, 1, 2567, 0, 0, 0, 1, 2569, 0, 0, 0, 1, 313, 0, 0, 0, 5, 2582, 197, 0, 0, 3, 296, 148, 2576, 0, 5, 2573, 163, 0, 0, 3, 296, 148, 2575, 0, 1, 2572, 0, 0, 0, 1, 2578, 0, 0, 0, 1, 2574, 0, 0, 0, 1, 2577, 0, 0, 0, 1, 2580, 0, 0, 0, 1, 2576, 0, 0, 0, 5, 2581, 163, 0, 0, 1, 2579, 0, 0, 0, 1, 2581, 0, 0, 0, 1, 2583, 0, 0, 0, 1, 2571, 0, 0, 0, 1, 2583, 0, 0, 0, 1, 2584, 0, 0, 0, 5, 2585, 198, 0, 0, 1, 315, 0, 0, 0, 5, 2587, 61, 0, 0, 3, 296, 148, 2588, 0, 1, 317, 0, 0, 0, 3, 320, 160, 2592, 0, 3, 322, 161, 2592, 0, 1, 2589, 0, 0, 0, 1, 2590, 0, 0, 0, 1, 319, 0, 0, 0, 5, 2594, 113, 0, 0, 3, 62, 31, 2596, 0, 3, 314, 157, 2597, 0, 1, 2595, 0, 0, 0, 1, 2597, 0, 0, 0, 1, 321, 0, 0, 0, 5, 2599, 113, 0, 0, 3, 152, 76, 2601, 0, 3, 62, 31, 2602, 0, 1, 2600, 0, 0, 0, 1, 2602, 0, 0, 0, 1, 2604, 0, 0, 0, 3, 314, 157, 2605, 0, 1, 2603, 0, 0, 0, 1, 2605, 0, 0, 0, 1, 323, 0, 0, 0, 5, 2607, 200, 0, 0, 3, 152, 76, 2608, 0, 5, 2609, 201, 0, 0, 3, 296, 148, 2610, 0, 1, 325, 0, 0, 0, 5, 2612, 27, 0, 0, 5, 2613, 200, 0, 0, 3, 296, 148, 2614, 0, 5, 2615, 201, 0, 0, 1, 2622, 0, 0, 0, 5, 2617, 14, 0, 0, 5, 2618, 200, 0, 0, 3, 296, 148, 2619, 0, 5, 2620, 201, 0, 0, 1, 2622, 0, 0, 0, 1, 2611, 0, 0, 0, 1, 2616, 0, 0, 0, 1, 327, 0, 0, 0, 5, 2635, 202, 0, 0, 3, 330, 165, 2629, 0, 5, 2626, 163, 0, 0, 3, 330, 165, 2628, 0, 1, 2625, 0, 0, 0, 1, 2631, 0, 0, 0, 1, 2627, 0, 0, 0, 1, 2630, 0, 0, 0, 1, 2633, 0, 0, 0, 1, 2629, 0, 0, 0, 5, 2634, 163, 0, 0, 1, 2632, 0, 0, 0, 1, 2634, 0, 0, 0, 1, 2636, 0, 0, 0, 1, 2624, 0, 0, 0, 1, 2636, 0, 0, 0, 1, 2637, 0, 0, 0, 5, 2638, 203, 0, 0, 1, 329, 0, 0, 0, 3, 332, 166, 2643, 0, 3, 334, 167, 2643, 0, 3, 336, 168, 2643, 0, 1, 2639, 0, 0, 0, 1, 2640, 0, 0, 0, 1, 2641, 0, 0, 0, 1, 331, 0, 0, 0, 3, 296, 148, 2645, 0, 1, 333, 0, 0, 0, 5, 2647, 130, 0, 0, 3, 296, 148, 2648, 0, 1, 335, 0, 0, 0, 5, 2650, 103, 0, 0, 3, 62, 31, 2651, 0, 1, 337, 0, 0, 0, 3, 152, 76, 2653, 0, 3, 234, 117, 2654, 0, 1, 339, 0, 0, 0, 5, 2656, 29, 0, 0, 5, 2657, 200, 0, 0, 3, 152, 76, 2658, 0, 5, 2659, 201, 0, 0, 1, 341, 0, 0, 0, 3, 44, 22, 2661, 0, 1, 343, 0, 0, 0, 5, 2663, 68, 0, 0, 1, 345, 0, 0, 0, 5, 2665, 113, 0, 0, 5, 2669, 202, 0, 0, 5, 2668, 163, 0, 0, 1, 2666, 0, 0, 0, 1, 2671, 0, 0, 0, 1, 2667, 0, 0, 0, 1, 2670, 0, 0, 0, 1, 2672, 0, 0, 0, 1, 2669, 0, 0, 0, 5, 2673, 203, 0, 0, 3, 314, 157, 2674, 0, 1, 347, 0, 0, 0, 3, 44, 22, 2676, 0, 1, 349, 0, 0, 0, 5, 2678, 5, 0, 0, 5, 2679, 202, 0, 0, 5, 2680, 203, 0, 0, 3, 314, 157, 2681, 0, 1, 351, 0, 0, 0, 3, 354, 177, 2685, 0, 3, 356, 178, 2685, 0, 1, 2682, 0, 0, 0, 1, 2683, 0, 0, 0, 1, 353, 0, 0, 0, 5, 2687, 81, 0, 0, 1, 355, 0, 0, 0, 5, 2689, 98, 0, 0, 1, 357, 0, 0, 0, 5, 2694, 194, 0, 0, 3, 360, 180, 2693, 0, 1, 2691, 0, 0, 0, 1, 2696, 0, 0, 0, 1, 2692, 0, 0, 0, 1, 2695, 0, 0, 0, 1, 2697, 0, 0, 0, 1, 2694, 0, 0, 0, 5, 2725, 157, 0, 0, 5, 2702, 195, 0, 0, 3, 360, 180, 2701, 0, 1, 2699, 0, 0, 0, 1, 2704, 0, 0, 0, 1, 2700, 0, 0, 0, 1, 2703, 0, 0, 0, 1, 2705, 0, 0, 0, 1, 2702, 0, 0, 0, 5, 2725, 157, 0, 0, 3, 370, 185, 2710, 0, 3, 360, 180, 2709, 0, 1, 2707, 0, 0, 0, 1, 2712, 0, 0, 0, 1, 2708, 0, 0, 0, 1, 2711, 0, 0, 0, 1, 2713, 0, 0, 0, 1, 2710, 0, 0, 0, 3, 372, 186, 2714, 0, 1, 2725, 0, 0, 0, 3, 374, 187, 2719, 0, 3, 360, 180, 2718, 0, 1, 2716, 0, 0, 0, 1, 2721, 0, 0, 0, 1, 2717, 0, 0, 0, 1, 2720, 0, 0, 0, 1, 2722, 0, 0, 0, 1, 2719, 0, 0, 0, 3, 372, 186, 2723, 0, 1, 2725, 0, 0, 0, 1, 2690, 0, 0, 0, 1, 2698, 0, 0, 0, 1, 2706, 0, 0, 0, 1, 2715, 0, 0, 0, 1, 359, 0, 0, 0, 3, 362, 181, 2729, 0, 3, 364, 182, 2729, 0, 1, 2726, 0, 0, 0, 1, 2727, 0, 0, 0, 1, 361, 0, 0, 0, 3, 468, 234, 2731, 0, 1, 363, 0, 0, 0, 5, 2733, 197, 0, 0, 3, 296, 148, 2735, 0, 3, 366, 183, 2736, 0, 1, 2734, 0, 0, 0, 1, 2736, 0, 0, 0, 1, 2738, 0, 0, 0, 3, 368, 184, 2739, 0, 1, 2737, 0, 0, 0, 1, 2739, 0, 0, 0, 1, 2740, 0, 0, 0, 5, 2741, 198, 0, 0, 1, 365, 0, 0, 0, 5, 2743, 163, 0, 0, 3, 296, 148, 2744, 0, 1, 367, 0, 0, 0, 5, 2746, 199, 0, 0, 3, 468, 234, 2747, 0, 1, 369, 0, 0, 0, 5, 2749, 196, 0, 0, 1, 371, 0, 0, 0, 5, 2754, 104, 0, 0, 5, 2753, 157, 0, 0, 1, 2751, 0, 0, 0, 1, 2756, 0, 0, 0, 1, 2752, 0, 0, 0, 1, 2755, 0, 0, 0, 1, 373, 0, 0, 0, 1, 2754, 0, 0, 0, 5, 2758, 196, 0, 0, 1, 375, 0, 0, 0, 5, 2773, 29, 0, 0, 5, 2773, 67, 0, 0, 5, 2773, 96, 0, 0, 5, 2773, 99, 0, 0, 5, 2773, 6, 0, 0, 3, 456, 228, 2773, 0, 3, 470, 235, 2773, 0, 3, 446, 223, 2773, 0, 3, 472, 236, 2773, 0, 3, 458, 229, 2773, 0, 3, 378, 189, 2773, 0, 3, 380, 190, 2773, 0, 3, 382, 191, 2773, 0, 1, 2759, 0, 0, 0, 1, 2760, 0, 0, 0, 1, 2761, 0, 0, 0, 1, 2762, 0, 0, 0, 1, 2763, 0, 0, 0, 1, 2764, 0, 0, 0, 1, 2765, 0, 0, 0, 1, 2766, 0, 0, 0, 1, 2767, 0, 0, 0, 1, 2768, 0, 0, 0, 1, 2769, 0, 0, 0, 1, 2770, 0, 0, 0, 1, 2771, 0, 0, 0, 1, 377, 0, 0, 0, 3, 470, 235, 2775, 0, 7, 2776, 15, 0, 0, 1, 379, 0, 0, 0, 3, 472, 236, 2778, 0, 7, 2779, 15, 0, 0, 1, 381, 0, 0, 0, 3, 458, 229, 2781, 0, 7, 2782, 15, 0, 0, 1, 383, 0, 0, 0, 5, 2784, 7, 0, 0, 5, 2785, 200, 0, 0, 3, 296, 148, 2786, 0, 5, 2787, 201, 0, 0, 1, 385, 0, 0, 0, 5, 2789, 165, 0, 0, 3, 20, 10, 2790, 0, 1, 387, 0, 0, 0, 5, 2792, 200, 0, 0, 3, 296, 148, 2793, 0, 5, 2794, 201, 0, 0, 1, 389, 0, 0, 0, 5, 2796, 156, 0, 0, 3, 296, 148, 2814, 0, 5, 2798, 160, 0, 0, 3, 296, 148, 2814, 0, 5, 2800, 161, 0, 0, 3, 296, 148, 2814, 0, 5, 2802, 162, 0, 0, 3, 296, 148, 2814, 0, 5, 2804, 125, 0, 0, 3, 296, 148, 2814, 0, 5, 2806, 164, 0, 0, 3, 296, 148, 2814, 0, 5, 2808, 127, 0, 0, 3, 296, 148, 2814, 0, 5, 2810, 172, 0, 0, 3, 296, 148, 2814, 0, 5, 2812, 175, 0, 0, 3, 296, 148, 2814, 0, 1, 2795, 0, 0, 0, 1, 2797, 0, 0, 0, 1, 2799, 0, 0, 0, 1, 2801, 0, 0, 0, 1, 2803, 0, 0, 0, 1, 2805, 0, 0, 0, 1, 2807, 0, 0, 0, 1, 2809, 0, 0, 0, 1, 2811, 0, 0, 0, 1, 391, 0, 0, 0, 3, 394, 197, 2816, 0, 3, 396, 198, 2817, 0, 1, 393, 0, 0, 0, 5, 2820, 89, 0, 0, 3, 152, 76, 2821, 0, 1, 2819, 0, 0, 0, 1, 2821, 0, 0, 0, 1, 2822, 0, 0, 0, 3, 442, 221, 2823, 0, 5, 2824, 149, 0, 0, 3, 296, 148, 2825, 0, 1, 395, 0, 0, 0, 3, 398, 199, 2828, 0, 1, 2826, 0, 0, 0, 1, 2831, 0, 0, 0, 1, 2827, 0, 0, 0, 1, 2830, 0, 0, 0, 1, 2832, 0, 0, 0, 1, 2829, 0, 0, 0, 3, 412, 206, 2834, 0, 3, 418, 209, 2835, 0, 1, 2833, 0, 0, 0, 1, 2835, 0, 0, 0, 1, 397, 0, 0, 0, 3, 394, 197, 2842, 0, 3, 400, 200, 2842, 0, 3, 404, 202, 2842, 0, 3, 406, 203, 2842, 0, 3, 410, 205, 2842, 0, 1, 2836, 0, 0, 0, 1, 2837, 0, 0, 0, 1, 2838, 0, 0, 0, 1, 2839, 0, 0, 0, 1, 2840, 0, 0, 0, 1, 399, 0, 0, 0, 5, 2845, 93, 0, 0, 3, 152, 76, 2846, 0, 1, 2844, 0, 0, 0, 1, 2846, 0, 0, 0, 1, 2847, 0, 0, 0, 3, 442, 221, 2848, 0, 5, 2849, 149, 0, 0, 3, 296, 148, 2850, 0, 5, 2851, 151, 0, 0, 3, 296, 148, 2852, 0, 5, 2853, 40, 0, 0, 3, 296, 148, 2855, 0, 3, 402, 201, 2856, 0, 1, 2854, 0, 0, 0, 1, 2856, 0, 0, 0, 1, 401, 0, 0, 0, 5, 2858, 92, 0, 0, 3, 442, 221, 2859, 0, 1, 403, 0, 0, 0, 5, 2861, 112, 0, 0, 3, 442, 221, 2862, 0, 5, 2863, 169, 0, 0, 3, 296, 148, 2864, 0, 1, 405, 0, 0, 0, 5, 2866, 33, 0, 0, 3, 408, 204, 2871, 0, 5, 2868, 163, 0, 0, 3, 408, 204, 2870, 0, 1, 2867, 0, 0, 0, 1, 2873, 0, 0, 0, 1, 2869, 0, 0, 0, 1, 2872, 0, 0, 0, 1, 407, 0, 0, 0, 1, 2871, 0, 0, 0, 3, 296, 148, 2876, 0, 7, 2877, 16, 0, 0, 1, 2875, 0, 0, 0, 1, 2877, 0, 0, 0, 1, 409, 0, 0, 0, 5, 2879, 78, 0, 0, 3, 296, 148, 2880, 0, 1, 411, 0, 0, 0, 3, 414, 207, 2884, 0, 3, 416, 208, 2884, 0, 1, 2881, 0, 0, 0, 1, 2882, 0, 0, 0, 1, 413, 0, 0, 0, 5, 2886, 71, 0, 0, 3, 296, 148, 2887, 0, 5, 2888, 146, 0, 0, 3, 296, 148, 2889, 0, 1, 415, 0, 0, 0, 5, 2891, 50, 0, 0, 3, 296, 148, 2892, 0, 1, 417, 0, 0, 0, 5, 2894, 92, 0, 0, 3, 442, 221, 2895, 0, 3, 396, 198, 2896, 0, 1, 419, 0, 0, 0, 5, 2898, 116, 0, 0, 3, 296, 148, 2899, 0, 1, 421, 0, 0, 0, 5, 2901, 8, 0, 0, 5, 2902, 200, 0, 0, 3, 296, 148, 2903, 0, 5, 2904, 201, 0, 0, 1, 423, 0, 0, 0, 5, 2906, 3, 0, 0, 5, 2907, 200, 0, 0, 3, 296, 148, 2908, 0, 5, 2909, 163, 0, 0, 3, 152, 76, 2910, 0, 5, 2911, 201, 0, 0, 1, 425, 0, 0, 0, 5, 2913, 51, 0, 0, 5, 2914, 200, 0, 0, 3, 152, 76, 2915, 0, 5, 2916, 201, 0, 0, 1, 427, 0, 0, 0, 5, 2918, 5, 0, 0, 3, 152, 76, 2920, 0, 3, 314, 157, 2921, 0, 1, 2919, 0, 0, 0, 1, 2921, 0, 0, 0, 1, 429, 0, 0, 0, 3, 228, 114, 2924, 0, 3, 270, 135, 2925, 0, 1, 2923, 0, 0, 0, 1, 2925, 0, 0, 0, 1, 2926, 0, 0, 0, 5, 2927, 138, 0, 0, 3, 296, 148, 2928, 0, 1, 431, 0, 0, 0, 5, 2930, 74, 0, 0, 3, 296, 148, 2931, 0, 1, 433, 0, 0, 0, 5, 2933, 200, 0, 0, 3, 46, 23, 2936, 0, 5, 2935, 163, 0, 0, 3, 46, 23, 2937, 0, 1, 2934, 0, 0, 0, 1, 2938, 0, 0, 0, 1, 2936, 0, 0, 0, 1, 2939, 0, 0, 0, 1, 2940, 0, 0, 0, 5, 2941, 201, 0, 0, 1, 435, 0, 0, 0, 5, 2943, 56, 0, 0, 5, 2944, 200, 0, 0, 3, 152, 76, 2945, 0, 5, 2946, 201, 0, 0, 1, 437, 0, 0, 0, 5, 2948, 57, 0, 0, 5, 2949, 200, 0, 0, 3, 296, 148, 2950, 0, 5, 2951, 201, 0, 0, 1, 439, 0, 0, 0, 3, 456, 228, 2960, 0, 3, 442, 221, 2960, 0, 3, 444, 222, 2960, 0, 3, 446, 223, 2960, 0, 3, 464, 232, 2960, 0, 3, 466, 233, 2960, 0, 3, 458, 229, 2960, 0, 1, 2952, 0, 0, 0, 1, 2953, 0, 0, 0, 1, 2954, 0, 0, 0, 1, 2955, 0, 0, 0, 1, 2956, 0, 0, 0, 1, 2957, 0, 0, 0, 1, 2958, 0, 0, 0, 1, 441, 0, 0, 0, 7, 2962, 17, 0, 0, 1, 443, 0, 0, 0, 5, 3029, 145, 0, 0, 5, 3029, 81, 0, 0, 5, 3029, 82, 0, 0, 5, 3029, 62, 0, 0, 5, 3029, 83, 0, 0, 5, 3029, 84, 0, 0, 5, 3029, 63, 0, 0, 5, 3029, 85, 0, 0, 5, 3029, 27, 0, 0, 5, 3029, 64, 0, 0, 5, 3029, 17, 0, 0, 5, 3029, 28, 0, 0, 5, 3029, 29, 0, 0, 5, 3029, 18, 0, 0, 5, 3029, 147, 0, 0, 5, 3029, 39, 0, 0, 5, 3029, 86, 0, 0, 5, 3029, 87, 0, 0, 5, 3029, 66, 0, 0, 5, 3029, 19, 0, 0, 5, 3029, 67, 0, 0, 5, 3029, 30, 0, 0, 5, 3029, 70, 0, 0, 5, 3029, 109, 0, 0, 5, 3029, 31, 0, 0, 5, 3029, 90, 0, 0, 5, 3029, 148, 0, 0, 5, 3029, 20, 0, 0, 5, 3029, 149, 0, 0, 5, 3029, 111, 0, 0, 5, 3029, 11, 0, 0, 5, 3029, 150, 0, 0, 5, 3029, 94, 0, 0, 5, 3029, 95, 0, 0, 5, 3029, 12, 0, 0, 5, 3029, 96, 0, 0, 5, 3029, 43, 0, 0, 5, 3029, 22, 0, 0, 5, 3029, 115, 0, 0, 5, 3029, 44, 0, 0, 5, 3029, 47, 0, 0, 5, 3029, 72, 0, 0, 5, 3029, 73, 0, 0, 5, 3029, 51, 0, 0, 5, 3029, 5, 0, 0, 5, 3029, 53, 0, 0, 5, 3029, 54, 0, 0, 5, 3029, 55, 0, 0, 5, 3029, 98, 0, 0, 5, 3029, 74, 0, 0, 5, 3029, 99, 0, 0, 5, 3029, 118, 0, 0, 5, 3029, 56, 0, 0, 5, 3029, 100, 0, 0, 5, 3029, 75, 0, 0, 5, 3029, 14, 0, 0, 5, 3029, 58, 0, 0, 5, 3029, 77, 0, 0, 5, 3029, 101, 0, 0, 5, 3029, 79, 0, 0, 5, 3029, 6, 0, 0, 5, 3029, 7, 0, 0, 5, 3029, 8, 0, 0, 5, 3029, 3, 0, 0, 3, 38, 19, 3029, 0, 1, 2963, 0, 0, 0, 1, 2964, 0, 0, 0, 1, 2965, 0, 0, 0, 1, 2966, 0, 0, 0, 1, 2967, 0, 0, 0, 1, 2968, 0, 0, 0, 1, 2969, 0, 0, 0, 1, 2970, 0, 0, 0, 1, 2971, 0, 0, 0, 1, 2972, 0, 0, 0, 1, 2973, 0, 0, 0, 1, 2974, 0, 0, 0, 1, 2975, 0, 0, 0, 1, 2976, 0, 0, 0, 1, 2977, 0, 0, 0, 1, 2978, 0, 0, 0, 1, 2979, 0, 0, 0, 1, 2980, 0, 0, 0, 1, 2981, 0, 0, 0, 1, 2982, 0, 0, 0, 1, 2983, 0, 0, 0, 1, 2984, 0, 0, 0, 1, 2985, 0, 0, 0, 1, 2986, 0, 0, 0, 1, 2987, 0, 0, 0, 1, 2988, 0, 0, 0, 1, 2989, 0, 0, 0, 1, 2990, 0, 0, 0, 1, 2991, 0, 0, 0, 1, 2992, 0, 0, 0, 1, 2993, 0, 0, 0, 1, 2994, 0, 0, 0, 1, 2995, 0, 0, 0, 1, 2996, 0, 0, 0, 1, 2997, 0, 0, 0, 1, 2998, 0, 0, 0, 1, 2999, 0, 0, 0, 1, 3000, 0, 0, 0, 1, 3001, 0, 0, 0, 1, 3002, 0, 0, 0, 1, 3003, 0, 0, 0, 1, 3004, 0, 0, 0, 1, 3005, 0, 0, 0, 1, 3006, 0, 0, 0, 1, 3007, 0, 0, 0, 1, 3008, 0, 0, 0, 1, 3009, 0, 0, 0, 1, 3010, 0, 0, 0, 1, 3011, 0, 0, 0, 1, 3012, 0, 0, 0, 1, 3013, 0, 0, 0, 1, 3014, 0, 0, 0, 1, 3015, 0, 0, 0, 1, 3016, 0, 0, 0, 1, 3017, 0, 0, 0, 1, 3018, 0, 0, 0, 1, 3019, 0, 0, 0, 1, 3020, 0, 0, 0, 1, 3021, 0, 0, 0, 1, 3022, 0, 0, 0, 1, 3023, 0, 0, 0, 1, 3024, 0, 0, 0, 1, 3025, 0, 0, 0, 1, 3026, 0, 0, 0, 1, 3027, 0, 0, 0, 1, 445, 0, 0, 0, 3, 448, 224, 3033, 0, 3, 454, 227, 3033, 0, 1, 3030, 0, 0, 0, 1, 3031, 0, 0, 0, 1, 447, 0, 0, 0, 3, 450, 225, 3038, 0, 3, 452, 226, 3038, 0, 5, 3038, 180, 0, 0, 1, 3034, 0, 0, 0, 1, 3035, 0, 0, 0, 1, 3036, 0, 0, 0, 1, 449, 0, 0, 0, 5, 3040, 178, 0, 0, 1, 451, 0, 0, 0, 5, 3042, 179, 0, 0, 1, 453, 0, 0, 0, 5, 3044, 181, 0, 0, 1, 455, 0, 0, 0, 5, 3046, 182, 0, 0, 1, 457, 0, 0, 0, 3, 460, 230, 3050, 0, 3, 462, 231, 3050, 0, 1, 3047, 0, 0, 0, 1, 3048, 0, 0, 0, 1, 459, 0, 0, 0, 5, 3052, 183, 0, 0, 1, 461, 0, 0, 0, 5, 3054, 184, 0, 0, 1, 463, 0, 0, 0, 5, 3095, 156, 0, 0, 5, 3095, 120, 0, 0, 5, 3095, 159, 0, 0, 5, 3095, 121, 0, 0, 5, 3095, 122, 0, 0, 5, 3095, 160, 0, 0, 5, 3095, 123, 0, 0, 5, 3095, 161, 0, 0, 5, 3095, 124, 0, 0, 5, 3095, 162, 0, 0, 5, 3095, 125, 0, 0, 5, 3095, 126, 0, 0, 5, 3095, 164, 0, 0, 5, 3095, 127, 0, 0, 5, 3095, 128, 0, 0, 5, 3095, 166, 0, 0, 5, 3095, 131, 0, 0, 5, 3095, 168, 0, 0, 5, 3095, 135, 0, 0, 5, 3095, 105, 0, 0, 5, 3095, 136, 0, 0, 5, 3095, 169, 0, 0, 5, 3095, 137, 0, 0, 5, 3095, 170, 0, 0, 5, 3095, 139, 0, 0, 3, 476, 238, 3095, 0, 3, 480, 240, 3095, 0, 3, 478, 239, 3095, 0, 3, 482, 241, 3095, 0, 5, 3095, 140, 0, 0, 5, 3095, 106, 0, 0, 5, 3095, 145, 0, 0, 5, 3095, 150, 0, 0, 5, 3095, 172, 0, 0, 5, 3095, 144, 0, 0, 5, 3095, 174, 0, 0, 5, 3095, 154, 0, 0, 5, 3095, 155, 0, 0, 5, 3095, 175, 0, 0, 1, 3055, 0, 0, 0, 1, 3056, 0, 0, 0, 1, 3057, 0, 0, 0, 1, 3058, 0, 0, 0, 1, 3059, 0, 0, 0, 1, 3060, 0, 0, 0, 1, 3061, 0, 0, 0, 1, 3062, 0, 0, 0, 1, 3063, 0, 0, 0, 1, 3064, 0, 0, 0, 1, 3065, 0, 0, 0, 1, 3066, 0, 0, 0, 1, 3067, 0, 0, 0, 1, 3068, 0, 0, 0, 1, 3069, 0, 0, 0, 1, 3070, 0, 0, 0, 1, 3071, 0, 0, 0, 1, 3072, 0, 0, 0, 1, 3073, 0, 0, 0, 1, 3074, 0, 0, 0, 1, 3075, 0, 0, 0, 1, 3076, 0, 0, 0, 1, 3077, 0, 0, 0, 1, 3078, 0, 0, 0, 1, 3079, 0, 0, 0, 1, 3080, 0, 0, 0, 1, 3081, 0, 0, 0, 1, 3082, 0, 0, 0, 1, 3083, 0, 0, 0, 1, 3084, 0, 0, 0, 1, 3085, 0, 0, 0, 1, 3086, 0, 0, 0, 1, 3087, 0, 0, 0, 1, 3088, 0, 0, 0, 1, 3089, 0, 0, 0, 1, 3090, 0, 0, 0, 1, 3091, 0, 0, 0, 1, 3092, 0, 0, 0, 1, 3093, 0, 0, 0, 1, 465, 0, 0, 0, 7, 3097, 18, 0, 0, 1, 467, 0, 0, 0, 5, 3099, 1, 0, 0, 1, 469, 0, 0, 0, 5, 3101, 186, 0, 0, 1, 471, 0, 0, 0, 5, 3103, 185, 0, 0, 1, 473, 0, 0, 0, 5, 3105, 176, 0, 0, 1, 475, 0, 0, 0, 5, 3107, 170, 0, 0, 5, 3108, 170, 0, 0, 4, 3109, 238, 17, 0, 1, 477, 0, 0, 0, 5, 3111, 170, 0, 0, 5, 3112, 170, 0, 0, 4, 3113, 239, 18, 0, 5, 3114, 170, 0, 0, 4, 3115, 239, 19, 0, 1, 479, 0, 0, 0, 5, 3117, 170, 0, 0, 5, 3118, 139, 0, 0, 4, 3119, 240, 20, 0, 1, 481, 0, 0, 0, 5, 3121, 170, 0, 0, 5, 3122, 170, 0, 0, 4, 3123, 241, 21, 0, 5, 3124, 139, 0, 0, 4, 3125, 241, 22, 0, 1, 483, 0, 0, 0, 3, 152, 76, 3127, 0, 3, 486, 243, 3132, 0, 5, 3129, 163, 0, 0, 3, 486, 243, 3131, 0, 1, 3128, 0, 0, 0, 1, 3134, 0, 0, 0, 1, 3130, 0, 0, 0, 1, 3133, 0, 0, 0, 1, 485, 0, 0, 0, 1, 3132, 0, 0, 0, 3, 442, 221, 3137, 0, 3, 48, 24, 3138, 0, 1, 3136, 0, 0, 0, 1, 3138, 0, 0, 0, 1, 487, 0, 0, 0, 0, 18, 1, 0, 2, 18, 2, 0, 2, 0, 20, 2, 1, 2, 2, 22, 1, 1, 4, 2, 23, 2, 0, 6, 0, 25, 5, 1, 6, 2, 30, 2, 1, 8, 2, 32, 13, 1, 10, 2, 45, 2, 1, 12, 2, 47, 2, 1, 14, 2, 49, 2, 0, 16, 0, 51, 32, 2, 16, 3, 83, 2, 1, 19, 2, 85, 2, 0, 21, 0, 87, 3, 2, 21, 3, 90, 2, 0, 24, 0, 92, 2, 1, 24, 2, 94, 32, 2, 26, 3, 126, 10, 2, 29, 4, 13, 13, 16, 16, 21, 21, 23, 26, 34, 36, 38, 38, 41, 41, 45, 45, 48, 49, 52, 52, 57, 57, 60, 60, 65, 65, 69, 69, 88, 88, 97, 97, 113, 113, 116, 116, 115, 116, 149, 149, 81, 81, 98, 98, 19, 20, 115, 115, 149, 149, 46, 46, 91, 91, 107, 107, 110, 110, 117, 117, 54, 54, 64, 64, 28, 28, 39, 39, 43, 43, 53, 53, 58, 58, 70, 70, 72, 73, 75, 75, 82, 83, 85, 85, 95, 95, 100, 101, 111, 111, 14, 14, 27, 27, 29, 29, 84, 84, 108, 108, 152, 152, 4, 4, 9, 10, 15, 15, 25, 25, 32, 34, 37, 38, 40, 40, 42, 42, 46, 46, 48, 48, 50, 50, 59, 61, 68, 68, 71, 71, 76, 76, 78, 78, 80, 80, 88, 89, 91, 93, 97, 97, 102, 103, 107, 107, 110, 110, 112, 112, 117, 117, 119, 119, 141, 141, 146, 146, 151, 151, 153, 153, 173, 173, 176, 177, 47, 47, 62, 62, 129, 129, 165, 165, 125, 125, 127, 127, 156, 156, 141, 141, 153, 153, 4, 4, 9, 9, 4, 4, 9, 10, 15, 15, 25, 25, 32, 34, 37, 38, 40, 40, 42, 42, 46, 46, 48, 48, 50, 50, 59, 61, 68, 68, 71, 71, 76, 76, 78, 78, 80, 80, 88, 89, 91, 93, 97, 97, 102, 103, 107, 108, 110, 110, 112, 112, 114, 114, 117, 117, 119, 119, 141, 141, 146, 146, 151, 153, 173, 173, 176, 177, 129, 130, 132, 134, 138, 138, 142, 143, 157, 158, 163, 163, 165, 165, 167, 167, 171, 171, 197, 203, 128000000, 303243868, 16777250, 1179650, 0, 0, 131072, 4, 1572864, 0, 0, 0, 0, 16384, 134217728, 2115584, 0, 4194304, 1, 0, 268435456, 69208192, 2150370112, 32816, 134234112, 0, 0, 0, 536870912, 0, 1048576, 0, 33588752, 939869543, 989941904, 10569922, 42213376, 204800, 0, 1073774592, 0, 0, 0, 0, 0, 2684354560, 268435456, 0, 528, 0, 0, 0, 33588752, 939869543, 989941904, 10836162, 58990592, 204800, 0, 0, 0, 0, 1610663030, 2216, 4064, 0, 491, 497, 503, 509, 520, 525, 528, 538, 542, 549, 559, 564, 571, 580, 587, 591, 595, 598, 608, 611, 616, 619, 621, 639, 643, 648, 654, 669, 674, 677, 685, 691, 694, 704, 710, 721, 726, 732, 738, 745, 753, 756, 763, 771, 773, 777, 781, 784, 796, 799, 806, 813, 824, 830, 835, 839, 848, 856, 862, 873, 878, 884, 889, 893, 899, 907, 915, 923, 927, 939, 947, 955, 965, 969, 971, 984, 990, 995, 999, 1036, 1044, 1048, 1053, 1059, 1068, 1074, 1080, 1086, 1092, 1101, 1107, 1113, 1118, 1123, 1128, 1134, 1140, 1145, 1151, 1159, 1165, 1174, 1179, 1185, 1190, 1198, 1206, 1214, 1220, 1225, 1232, 1236, 1240, 1244, 1249, 1255, 1261, 1269, 1273, 1275, 1278, 1281, 1289, 1294, 1304, 1310, 1315, 1323, 1328, 1334, 1340, 1343, 1346, 1351, 1358, 1362, 1365, 1370, 1376, 1381, 1384, 1389, 1396, 1404, 1410, 1416, 1419, 1422, 1427, 1434, 1438, 1441, 1446, 1452, 1457, 1461, 1464, 1467, 1472, 1479, 1483, 1486, 1491, 1497, 1503, 1506, 1509, 1514, 1521, 1525, 1528, 1533, 1539, 1545, 1548, 1551, 1556, 1563, 1567, 1570, 1575, 1581, 1588, 1594, 1602, 1608, 1620, 1626, 1632, 1634, 1641, 1645, 1649, 1653, 1656, 1663, 1669, 1673, 1675, 1683, 1696, 1704, 1710, 1719, 1732, 1738, 1764, 1769, 1774, 1781, 1789, 1794, 1798, 1812, 1816, 1829, 1834, 1841, 1855, 1863, 1872, 1884, 1890, 1897, 1900, 1902, 1906, 1914, 1917, 1925, 1930, 1933, 1940, 1949, 1957, 1967, 1971, 1974, 1979, 1988, 1994, 2000, 2006, 2013, 2018, 2030, 2035, 2042, 2053, 2061, 2066, 2071, 2076, 2092, 2099, 2110, 2120, 2123, 2137, 2141, 2143, 2147, 2154, 2157, 2160, 2163, 2171, 2174, 2179, 2185, 2196, 2200, 2202, 2218, 2222, 2245, 2250, 2257, 2265, 2269, 2273, 2276, 2283, 2298, 2307, 2311, 2317, 2325, 2337, 2343, 2373, 2386, 2402, 2428, 2455, 2465, 2469, 2471, 2477, 2479, 2484, 2489, 2494, 2498, 2502, 2507, 2513, 2517, 2523, 2528, 2534, 2541, 2550, 2554, 2556, 2561, 2568, 2576, 2580, 2582, 2591, 2596, 2601, 2604, 2621, 2629, 2633, 2635, 2642, 2669, 2684, 2694, 2702, 2710, 2719, 2724, 2728, 2735, 2738, 2754, 2772, 2813, 2820, 2829, 2834, 2841, 2845, 2855, 2871, 2876, 2883, 2920, 2924, 2938, 2959, 3028, 3032, 3037, 3049, 3094, 3132, 3137, 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, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, 261, 263, 265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 323, 325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351, 353, 355, 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, 377, 379, 381, 383, 385, 387, 389, 391, 393, 395, 397, 399, 401, 403, 405, 407, 409, 411, 413, 415, 417, 419, 421, 423, 425, 427, 429, 431, 433, 435, 437, 439, 441, 443, 445, 447, 449, 451, 453, 455, 457, 459, 461, 463, 465, 467, 469, 471, 473, 475, 477, 479, 481, 483, 485, 487];
static ATN_CELL: OnceLock<ParserAtn> = OnceLock::new();

/// Validates and caches the packed grammar ATN for all parser instances.
fn atn() -> &'static ParserAtn {
    ATN_CELL.get_or_init(|| {
        ParserAtn::from_static(PARSER_ATN_DATA)
            .unwrap_or_else(|error| panic!("generated parser ATN is incompatible with this runtime: {error}"))
    })
}

/// Borrows the validated packed parser ATN embedded in this module.
pub fn parser_atn() -> &'static ParserAtn {
    atn()
}

/// Result from [`parse_with_parser`] or [`parse_stream_with_parser`].
///
/// Keeps the generated parser available after the entry rule runs so callers
/// can inspect diagnostics or recover the parser-owned token stream.
#[derive(Debug)]
pub struct CSharpParserParseOutput<R, L>
where
    L: TokenSource,
{
    pub result: R,
    pub parser: CSharpParser<L>,
}

impl<L: TokenSource> CSharpParserParseOutput<antlr4_runtime::NodeId, L> {
    /// Validates a completed parse and changes its generated context surface.
    ///
    /// Validation rejects lexer diagnostics, parser recovery, recovered error
    /// nodes, and missing generated required children before constructing the
    /// validated-tree type boundary.
    pub fn validate(self) -> Result<CSharpValidatedTree, CSharpValidationError> {
        let lexer = self.parser.token_stream().number_of_source_errors();
        let parser = self.parser.number_of_syntax_errors();
        if lexer != 0 || parser != 0 {
            return Err(CSharpValidationError::SyntaxErrors { lexer, parser });
        }
        let parsed = self.parser.into_parsed_file(self.result);
        validate_tree_structure(&parsed)?;
        Ok(CSharpValidatedTree::__new(parsed))
    }
}

/// Parses UTF-8 text by constructing the lexer, token stream, parser, and
/// caller-selected entry rule in one call.
///
/// Pass the generated lexer constructor and a parser entry rule, for example
/// `parse(src, MyGrammarLexer::new, CSharpParser::file)`.
///
/// The returned [`antlr4_runtime::ParsedFile`] owns the canonical token store,
/// flat CST storage, and entry-rule root.
/// Use [`parse_with_parser`] instead when the caller also needs parser
/// diagnostics after the entry rule runs.
pub fn parse<L: TokenSource>(
    input: impl AsRef<str>,
    lexer: impl FnOnce(antlr4_runtime::InputStream) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<antlr4_runtime::ParsedFile, antlr4_runtime::AntlrError>
{
    parse_stream(antlr4_runtime::InputStream::new(input.as_ref()), lexer, entry)
}

/// Parses UTF-8 text and returns a typed tree whose required generated child
/// accessors are infallible.
pub fn parse_validated<L: TokenSource>(
    input: impl AsRef<str>,
    lexer: impl FnOnce(antlr4_runtime::InputStream) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<CSharpValidatedTree, CSharpValidationError>
{
    parse_stream_validated(
        antlr4_runtime::InputStream::new(input.as_ref()),
        lexer,
        entry,
    )
}

/// Parses UTF-8 text like [`parse`] while returning the parser after the entry
/// rule has run.
///
/// This keeps the compact generated setup path available for callers that also
/// need `Parser::number_of_syntax_errors()` or `CSharpParser::into_token_stream()`.
pub fn parse_with_parser<L: TokenSource, R>(
    input: impl AsRef<str>,
    lexer: impl FnOnce(antlr4_runtime::InputStream) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<CSharpParserParseOutput<R, L>, antlr4_runtime::AntlrError>
{
    parse_stream_with_parser(
        antlr4_runtime::InputStream::new(input.as_ref()),
        lexer,
        entry,
    )
}

/// Parses a caller-provided character stream by constructing the lexer, token
/// stream, parser, and caller-selected entry rule in one call.
///
/// Unlike [`parse`], this accepts any [`antlr4_runtime::CharStream`], including
/// a named [`antlr4_runtime::InputStream`] or a byte-oriented
/// [`antlr4_runtime::ByteStream`].
pub fn parse_stream<I: antlr4_runtime::CharStream, L: TokenSource>(
    input: I,
    lexer: impl FnOnce(I) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<antlr4_runtime::ParsedFile, antlr4_runtime::AntlrError>
{
    let CSharpParserParseOutput { result, parser } =
        parse_stream_with_parser(input, lexer, entry)?;
    Ok(parser.into_parsed_file(result))
}

/// Parses a caller-provided character stream and validates the completed tree.
pub fn parse_stream_validated<I: antlr4_runtime::CharStream, L: TokenSource>(
    input: I,
    lexer: impl FnOnce(I) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<CSharpValidatedTree, CSharpValidationError>
{
    let output = parse_stream_with_parser(input, lexer, entry)
        .map_err(CSharpValidationError::Recognition)?;
    output.validate()
}

/// Parses a caller-provided character stream like [`parse_stream`] while
/// returning the parser after the entry rule has run.
pub fn parse_stream_with_parser<I: antlr4_runtime::CharStream, L: TokenSource, R>(
    input: I,
    lexer: impl FnOnce(I) -> L,
    entry: impl FnOnce(&mut CSharpParser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<CSharpParserParseOutput<R, L>, antlr4_runtime::AntlrError>
{
    let lexer = lexer(input);
    let tokens = CommonTokenStream::new(lexer);
    let mut parser = CSharpParser::new(tokens);
    let result = entry(&mut parser)?;
    Ok(CSharpParserParseOutput { result, parser })
}

/// Generated parser. Each grammar rule is exposed as a public method.
///
/// Pick an entry-rule method that matches the grammar's intended
/// top-level construct for the input being parsed. The generator can
/// infer entry candidates from call paths that reach explicit `EOF`
/// matches, from parser rules that no other rule calls, and from
/// configured entry rules. It cannot infer the semantic choice
/// between multiple candidates.
///
/// Likely parser entry-rule methods:
/// - `compilation_unit()`
///
/// All parser rule methods:
/// - `compilation_unit()`
/// - `extern_alias_directive()`
/// - `using_directive()`
/// - `name_equals()`
/// - `identifier_name()`
/// - `attribute_list()`
/// - `attribute_target_specifier()`
/// - `attribute()`
/// - `name()`
/// - `alias_qualified_name()`
/// - `simple_name()`
/// - `generic_name()`
/// - `type_argument_list()`
/// - `attribute_argument_list()`
/// - `attribute_argument()`
/// - `name_colon()`
/// - `member_declaration()`
/// - `base_field_declaration()`
/// - `event_field_declaration()`
/// - `modifier()`
/// - `variable_declaration()`
/// - `variable_declarator()`
/// - `bracketed_argument_list()`
/// - `argument()`
/// - `equals_value_clause()`
/// - `field_declaration()`
/// - `base_method_declaration()`
/// - `constructor_declaration()`
/// - `parameter_list()`
/// - `parameter()`
/// - `constructor_initializer()`
/// - `argument_list()`
/// - `block()`
/// - `arrow_expression_clause()`
/// - `conversion_operator_declaration()`
/// - `explicit_interface_specifier()`
/// - `destructor_declaration()`
/// - `method_declaration()`
/// - `type_parameter_list()`
/// - `type_parameter()`
/// - `type_parameter_constraint_clause()`
/// - `type_parameter_constraint()`
/// - `allows_constraint_clause()`
/// - `allows_constraint()`
/// - `ref_struct_constraint()`
/// - `class_or_struct_constraint()`
/// - `constructor_constraint()`
/// - `default_constraint()`
/// - `type_constraint()`
/// - `operator_declaration()`
/// - `base_namespace_declaration()`
/// - `file_scoped_namespace_declaration()`
/// - `namespace_declaration()`
/// - `base_property_declaration()`
/// - `event_declaration()`
/// - `accessor_list()`
/// - `accessor_declaration()`
/// - `indexer_declaration()`
/// - `bracketed_parameter_list()`
/// - `property_declaration()`
/// - `base_type_declaration()`
/// - `enum_declaration()`
/// - `base_list()`
/// - `base_type()`
/// - `primary_constructor_base_type()`
/// - `simple_base_type()`
/// - `enum_member_declaration()`
/// - `type_declaration()`
/// - `class_declaration()`
/// - `extension_block_declaration()`
/// - `interface_declaration()`
/// - `record_declaration()`
/// - `struct_declaration()`
/// - `union_declaration()`
/// - `delegate_declaration()`
/// - `global_statement()`
/// - `r#type()`
/// - `array_type()`
/// - `array_rank_specifier()`
/// - `function_pointer_type()`
/// - `function_pointer_calling_convention()`
/// - `function_pointer_unmanaged_calling_convention_list()`
/// - `function_pointer_unmanaged_calling_convention()`
/// - `function_pointer_parameter_list()`
/// - `function_pointer_parameter()`
/// - `predefined_type()`
/// - `ref_type()`
/// - `scoped_type()`
/// - `tuple_type()`
/// - `tuple_element()`
/// - `statement()`
/// - `break_statement()`
/// - `checked_statement()`
/// - `common_for_each_statement()`
/// - `for_each_statement()`
/// - `for_each_variable_statement()`
/// - `continue_statement()`
/// - `do_statement()`
/// - `empty_statement()`
/// - `expression_statement()`
/// - `fixed_statement()`
/// - `for_statement()`
/// - `goto_statement()`
/// - `if_statement()`
/// - `else_clause()`
/// - `labeled_statement()`
/// - `local_declaration_statement()`
/// - `local_function_statement()`
/// - `lock_statement()`
/// - `return_statement()`
/// - `switch_statement()`
/// - `switch_section()`
/// - `switch_label()`
/// - `case_pattern_switch_label()`
/// - `pattern()`
/// - `constant_pattern()`
/// - `declaration_pattern()`
/// - `variable_designation()`
/// - `discard_designation()`
/// - `parenthesized_variable_designation()`
/// - `single_variable_designation()`
/// - `discard_pattern()`
/// - `list_pattern()`
/// - `parenthesized_pattern()`
/// - `recursive_pattern()`
/// - `positional_pattern_clause()`
/// - `subpattern()`
/// - `base_expression_colon()`
/// - `expression_colon()`
/// - `property_pattern_clause()`
/// - `relational_pattern()`
/// - `slice_pattern()`
/// - `type_pattern()`
/// - `unary_pattern()`
/// - `var_pattern()`
/// - `when_clause()`
/// - `case_switch_label()`
/// - `default_switch_label()`
/// - `throw_statement()`
/// - `try_statement()`
/// - `catch_clause()`
/// - `catch_declaration()`
/// - `catch_filter_clause()`
/// - `finally_clause()`
/// - `unsafe_statement()`
/// - `using_statement()`
/// - `while_statement()`
/// - `yield_statement()`
/// - `expression()`
/// - `anonymous_function_expression()`
/// - `anonymous_method_expression()`
/// - `lambda_expression()`
/// - `parenthesized_lambda_expression()`
/// - `simple_lambda_expression()`
/// - `anonymous_object_creation_expression()`
/// - `anonymous_object_member_declarator()`
/// - `array_creation_expression()`
/// - `initializer_expression()`
/// - `await_expression()`
/// - `base_object_creation_expression()`
/// - `implicit_object_creation_expression()`
/// - `object_creation_expression()`
/// - `cast_expression()`
/// - `checked_expression()`
/// - `collection_expression()`
/// - `collection_element()`
/// - `expression_element()`
/// - `spread_element()`
/// - `with_element()`
/// - `declaration_expression()`
/// - `default_expression()`
/// - `element_binding_expression()`
/// - `field_expression()`
/// - `implicit_array_creation_expression()`
/// - `implicit_element_access()`
/// - `implicit_stack_alloc_array_creation_expression()`
/// - `instance_expression()`
/// - `base_expression()`
/// - `this_expression()`
/// - `interpolated_string_expression()`
/// - `interpolated_string_content()`
/// - `interpolated_string_text()`
/// - `interpolation()`
/// - `interpolation_alignment_clause()`
/// - `interpolation_format_clause()`
/// - `interpolated_multi_line_raw_string_start_token()`
/// - `interpolated_raw_string_end_token()`
/// - `interpolated_single_line_raw_string_start_token()`
/// - `literal_expression()`
/// - `utf8_multi_line_raw_string_literal_token()`
/// - `utf8_single_line_raw_string_literal_token()`
/// - `utf8_string_literal_token()`
/// - `make_ref_expression()`
/// - `member_binding_expression()`
/// - `parenthesized_expression()`
/// - `prefix_unary_expression()`
/// - `query_expression()`
/// - `from_clause()`
/// - `query_body()`
/// - `query_clause()`
/// - `join_clause()`
/// - `join_into_clause()`
/// - `let_clause()`
/// - `order_by_clause()`
/// - `ordering()`
/// - `where_clause()`
/// - `select_or_group_clause()`
/// - `group_clause()`
/// - `select_clause()`
/// - `query_continuation()`
/// - `ref_expression()`
/// - `ref_type_expression()`
/// - `ref_value_expression()`
/// - `size_of_expression()`
/// - `stack_alloc_array_creation_expression()`
/// - `switch_expression_arm()`
/// - `throw_expression()`
/// - `tuple_expression()`
/// - `type_of_expression()`
/// - `unsafe_expression()`
/// - `syntax_token()`
/// - `identifier_token()`
/// - `keyword()`
/// - `numeric_literal_token()`
/// - `integer_literal_token()`
/// - `decimal_integer_literal_token()`
/// - `hexadecimal_integer_literal_token()`
/// - `real_literal_token()`
/// - `character_literal_token()`
/// - `string_literal_token()`
/// - `regular_string_literal_token()`
/// - `verbatim_string_literal_token()`
/// - `operator_token()`
/// - `punctuation_token()`
/// - `interpolated_string_text_token()`
/// - `multi_line_raw_string_literal_token()`
/// - `single_line_raw_string_literal_token()`
/// - `record_keyword()`
/// - `right_shift()`
/// - `unsigned_right_shift()`
/// - `right_shift_assignment()`
/// - `unsigned_right_shift_assignment()`
/// - `local_variable_declaration()`
/// - `local_variable_declarator()`
#[derive(Debug)]
pub struct CSharpParser<L, H = antlr4_runtime::NoSemanticHooks>
where
    L: TokenSource,
    H: antlr4_runtime::SemanticHooks,
{
    base: BaseParser<L, H>,
    simulator: Option<antlr4_runtime::ParserAtnSimulator<'static>>,
    generated_only: bool,
    adaptive_atn_preferred_rules: [bool; 2],
    adaptive_atn_preference_depths: [usize; 2],
    adaptive_atn_preference_starts: [(usize, usize); 2],
    adaptive_atn_syntax_error_starts: [usize; 2],
    adaptive_atn_retry_slot: Option<usize>,
}

#[allow(dead_code)]
#[derive(Debug)]
enum GeneratedRuleError {
    Fatal(antlr4_runtime::AntlrError),
    Interpreted(antlr4_runtime::AntlrError),
    AdaptiveRetry,
}

impl GeneratedRuleError {
    fn into_error(self) -> antlr4_runtime::AntlrError {
        match self {
            Self::Fatal(error) | Self::Interpreted(error) => error,
            Self::AdaptiveRetry => antlr4_runtime::AntlrError::Unsupported("internal adaptive ATN retry escaped its routing boundary".to_owned()),
        }
    }
}
impl<L> CSharpParser<L, antlr4_runtime::NoSemanticHooks>
where
    L: TokenSource,
{
    pub fn new(input: CommonTokenStream<L>) -> Self {
        Self::with_hooks(input, antlr4_runtime::NoSemanticHooks)
    }
}

impl<L, H> CSharpParser<L, H>
where
    L: TokenSource,
    H: antlr4_runtime::SemanticHooks,
{
    pub fn with_hooks(input: CommonTokenStream<L>, hooks: H) -> Self {
        let grammar_metadata = metadata();
        let data = grammar_metadata.recognizer_data();
        let mut base = BaseParser::with_semantic_hooks(input, data, hooks);
        base.set_unknown_predicate_policy(antlr4_runtime::UnknownSemanticPolicy::Error);
        Self {
            base,
            simulator: None,
            generated_only: std::env::var_os("ANTLR4_RUST_GENERATED_ONLY").is_some(),
            adaptive_atn_preferred_rules: [false; 2],
            adaptive_atn_preference_depths: [0; 2],
            adaptive_atn_preference_starts: [(0, 0); 2],
            adaptive_atn_syntax_error_starts: [0; 2],
            adaptive_atn_retry_slot: None,
        }
    }

    #[allow(dead_code)]
    fn parse_rule(&mut self, rule_index: usize) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence(rule_index, 0)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence_inner(rule_index, precedence, true)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence_from_generated(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence_inner(rule_index, precedence, false)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence_inner(&mut self, rule_index: usize, precedence: i32, allow_generated_fallback: bool) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        if allow_generated_fallback {
            // True top-level entry: drop any fail-loud coordinates left by a
            // previous parse so a reused parser starts clean. Mid-parse the hits
            // are preserved so a generated parent can surface a recovered child's
            // fail-loud coordinate at this boundary.
            self.base.reset_unknown_semantic_hits();
            // Likewise drop stale sticky aborts (depth-cap violation,
            // parse-listener abort): entry rules share one parser instance,
            // and the flags must not poison the next parse when the previous
            // one exited through an error path.
            let _ = self.base.take_parse_abort();
        }
        let __rule_start = antlr4_runtime::IntStream::index(self.base.input());
        let __generated_only = self.generated_only();
        let __tree = if let Some(result) = self.parse_generated_rule(rule_index, precedence, allow_generated_fallback) {
            match result {
                Ok(tree) => tree,
                Err(error) => {
                    antlr4_runtime::IntStream::seek(self.base.input(), __rule_start);
                    let __report_error =
                        matches!(&error, GeneratedRuleError::Fatal(_));
                    // A fatal unwind retains recovery diagnostics committed
                    // earlier in this entry. Dispatch them before a semantic
                    // or parser-abort override can return, or they would leak
                    // into the next entry on a reused parser.
                    if allow_generated_fallback && __report_error {
                        self.base.report_generated_parser_diagnostics();
                    }
                    if allow_generated_fallback {
                        // A sticky abort (depth cap, listener) wins over an
                        // error or semantic miss derived after recovery absorbed
                        // the aborted rule. Drain any masked semantic miss too,
                        // so neither condition poisons the next entry.
                        if let Some(abort) = self.base.take_parse_abort() {
                            let _ = self.base.take_unknown_semantic_error();
                            return Err(abort);
                        }
                        // A generated predicate that consulted an unimplemented
                        // hook fails the alternative and surfaces here as a generic
                        // failed-predicate/rule error. Prefer the recorded fail-loud
                        // semantic error when no parser abort occurred.
                        if let Some(semantic_error) = self.base.take_unknown_semantic_error() {
                            return Err(semantic_error);
                        }
                    }
                    let error = error.into_error();
                    if allow_generated_fallback && __report_error {
                        self.base.report_unrecovered_parser_error(&error);
                    }
                    return Err(error);
                }
            }
        } else if __generated_only {
            return Err(antlr4_runtime::AntlrError::Unsupported(format!("generated parser did not emit rule {}", rule_index)));
        } else {
            self.parse_interpreted_rule_precedence(rule_index, precedence)?
        };
        if allow_generated_fallback {
            self.base.report_generated_parser_diagnostics();
            // A sticky abort (depth-cap violation, listener abort) is not a
            // syntax error: rule-level recovery may have produced a tree
            // and semantic miss anyway, but the abort is the root cause. Drain
            // both sticky conditions before returning so parser reuse is clean.
            if let Some(error) = self.base.take_parse_abort() {
                let _ = self.base.take_unknown_semantic_error();
                return Err(error);
            }
            // Surface unknown predicate/action coordinates recorded under the
            // Error policy only after parser aborts have been ruled out.
            if let Some(error) = self.base.take_unknown_semantic_error() {
                return Err(error);
            }
        }
        Ok(__tree)
    }

    #[allow(dead_code)]
    fn parse_interpreted_rule(&mut self, rule_index: usize) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_interpreted_rule_precedence(rule_index, 0)
    }

    #[allow(dead_code)]
    fn parse_interpreted_rule_precedence(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        if precedence == 0 && false && std::env::var_os("ANTLR4_RUST_ADAPTIVE_DIRECT").is_some() {
            let simulator = self
                .simulator
                .get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
            self.base
                .parse_atn_rule_adaptive_or_fallback(atn(), simulator, rule_index)
        } else {
        let (tree, actions) = self.base.parse_atn_rule_with_runtime_options_and_precedence(atn(), rule_index, precedence, antlr4_runtime::ParserRuntimeOptions { action_indices: &[], track_alt_numbers: false, track_context_alt_numbers: false, predicates: &[], semantics: Some(parser_semantics()), rule_args: &[], member_actions: &[], return_actions: &[], unknown_predicate_policy: antlr4_runtime::UnknownSemanticPolicy::Error , ..antlr4_runtime::ParserRuntimeOptions::default() })?;
        for action in actions { self.run_action(action, tree); }
        Ok(tree)
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule(&mut self, rule_index: usize, precedence: i32, allow_fallback: bool) -> Option<Result<antlr4_runtime::ParseTree, GeneratedRuleError>> {
        let _ = precedence;
        let _ = allow_fallback;
        match rule_index {
            0 => Some(self.parse_generated_rule_0_dispatch(precedence, allow_fallback)),
            1 => Some(self.parse_generated_rule_1_dispatch(precedence, allow_fallback)),
            2 => Some(self.parse_generated_rule_2_dispatch(precedence, allow_fallback)),
            3 => Some(self.parse_generated_rule_3_dispatch(precedence, allow_fallback)),
            4 => Some(self.parse_generated_rule_4_dispatch(precedence, allow_fallback)),
            5 => Some(self.parse_generated_rule_5_dispatch(precedence, allow_fallback)),
            6 => Some(self.parse_generated_rule_6_dispatch(precedence, allow_fallback)),
            7 => Some(self.parse_generated_rule_7_dispatch(precedence, allow_fallback)),
            8 => Some(self.parse_generated_rule_8_dispatch(precedence, allow_fallback)),
            9 => Some(self.parse_generated_rule_9_dispatch(precedence, allow_fallback)),
            10 => Some(self.parse_generated_rule_10_dispatch(precedence, allow_fallback)),
            11 => Some(self.parse_generated_rule_11_dispatch(precedence, allow_fallback)),
            12 => Some(self.parse_generated_rule_12_dispatch(precedence, allow_fallback)),
            13 => Some(self.parse_generated_rule_13_dispatch(precedence, allow_fallback)),
            14 => Some(self.parse_generated_rule_14_dispatch(precedence, allow_fallback)),
            15 => Some(self.parse_generated_rule_15_dispatch(precedence, allow_fallback)),
            16 => Some(self.parse_generated_rule_16_dispatch(precedence, allow_fallback)),
            17 => Some(self.parse_generated_rule_17_dispatch(precedence, allow_fallback)),
            18 => Some(self.parse_generated_rule_18_dispatch(precedence, allow_fallback)),
            19 => Some(self.parse_generated_rule_19_dispatch(precedence, allow_fallback)),
            20 => Some(self.parse_generated_rule_20_dispatch(precedence, allow_fallback)),
            21 => Some(self.parse_generated_rule_21_dispatch(precedence, allow_fallback)),
            22 => Some(self.parse_generated_rule_22_dispatch(precedence, allow_fallback)),
            23 => Some(self.parse_generated_rule_23_dispatch(precedence, allow_fallback)),
            24 => Some(self.parse_generated_rule_24_dispatch(precedence, allow_fallback)),
            25 => Some(self.parse_generated_rule_25_dispatch(precedence, allow_fallback)),
            26 => Some(self.parse_generated_rule_26_dispatch(precedence, allow_fallback)),
            27 => Some(self.parse_generated_rule_27_dispatch(precedence, allow_fallback)),
            28 => Some(self.parse_generated_rule_28_dispatch(precedence, allow_fallback)),
            29 => Some(self.parse_generated_rule_29_dispatch(precedence, allow_fallback)),
            30 => Some(self.parse_generated_rule_30_dispatch(precedence, allow_fallback)),
            31 => Some(self.parse_generated_rule_31_dispatch(precedence, allow_fallback)),
            32 => Some(self.parse_generated_rule_32_dispatch(precedence, allow_fallback)),
            33 => Some(self.parse_generated_rule_33_dispatch(precedence, allow_fallback)),
            34 => Some(self.parse_generated_rule_34_dispatch(precedence, allow_fallback)),
            35 => Some(self.parse_generated_rule_35_dispatch(precedence, allow_fallback)),
            36 => Some(self.parse_generated_rule_36_dispatch(precedence, allow_fallback)),
            37 => Some(self.parse_generated_rule_37_dispatch(precedence, allow_fallback)),
            38 => Some(self.parse_generated_rule_38_dispatch(precedence, allow_fallback)),
            39 => Some(self.parse_generated_rule_39_dispatch(precedence, allow_fallback)),
            40 => Some(self.parse_generated_rule_40_dispatch(precedence, allow_fallback)),
            41 => Some(self.parse_generated_rule_41_dispatch(precedence, allow_fallback)),
            42 => Some(self.parse_generated_rule_42_dispatch(precedence, allow_fallback)),
            43 => Some(self.parse_generated_rule_43_dispatch(precedence, allow_fallback)),
            44 => Some(self.parse_generated_rule_44_dispatch(precedence, allow_fallback)),
            45 => Some(self.parse_generated_rule_45_dispatch(precedence, allow_fallback)),
            46 => Some(self.parse_generated_rule_46_dispatch(precedence, allow_fallback)),
            47 => Some(self.parse_generated_rule_47_dispatch(precedence, allow_fallback)),
            48 => Some(self.parse_generated_rule_48_dispatch(precedence, allow_fallback)),
            49 => Some(self.parse_generated_rule_49_dispatch(precedence, allow_fallback)),
            50 => Some(self.parse_generated_rule_50_dispatch(precedence, allow_fallback)),
            51 => Some(self.parse_generated_rule_51_dispatch(precedence, allow_fallback)),
            52 => Some(self.parse_generated_rule_52_dispatch(precedence, allow_fallback)),
            53 => Some(self.parse_generated_rule_53_dispatch(precedence, allow_fallback)),
            54 => Some(self.parse_generated_rule_54_dispatch(precedence, allow_fallback)),
            55 => Some(self.parse_generated_rule_55_dispatch(precedence, allow_fallback)),
            56 => Some(self.parse_generated_rule_56_dispatch(precedence, allow_fallback)),
            57 => Some(self.parse_generated_rule_57_dispatch(precedence, allow_fallback)),
            58 => Some(self.parse_generated_rule_58_dispatch(precedence, allow_fallback)),
            59 => Some(self.parse_generated_rule_59_dispatch(precedence, allow_fallback)),
            60 => Some(self.parse_generated_rule_60_dispatch(precedence, allow_fallback)),
            61 => Some(self.parse_generated_rule_61_dispatch(precedence, allow_fallback)),
            62 => Some(self.parse_generated_rule_62_dispatch(precedence, allow_fallback)),
            63 => Some(self.parse_generated_rule_63_dispatch(precedence, allow_fallback)),
            64 => Some(self.parse_generated_rule_64_dispatch(precedence, allow_fallback)),
            65 => Some(self.parse_generated_rule_65_dispatch(precedence, allow_fallback)),
            66 => Some(self.parse_generated_rule_66_dispatch(precedence, allow_fallback)),
            67 => Some(self.parse_generated_rule_67_dispatch(precedence, allow_fallback)),
            68 => Some(self.parse_generated_rule_68_dispatch(precedence, allow_fallback)),
            69 => Some(self.parse_generated_rule_69_dispatch(precedence, allow_fallback)),
            70 => Some(self.parse_generated_rule_70_dispatch(precedence, allow_fallback)),
            71 => Some(self.parse_generated_rule_71_dispatch(precedence, allow_fallback)),
            72 => Some(self.parse_generated_rule_72_dispatch(precedence, allow_fallback)),
            73 => Some(self.parse_generated_rule_73_dispatch(precedence, allow_fallback)),
            74 => Some(self.parse_generated_rule_74_dispatch(precedence, allow_fallback)),
            75 => Some(self.parse_generated_rule_75_dispatch(precedence, allow_fallback)),
            76 => Some(self.parse_generated_rule_76_dispatch(precedence, allow_fallback)),
            77 => Some(self.parse_generated_rule_77_dispatch(precedence, allow_fallback)),
            78 => Some(self.parse_generated_rule_78_dispatch(precedence, allow_fallback)),
            79 => Some(self.parse_generated_rule_79_dispatch(precedence, allow_fallback)),
            80 => Some(self.parse_generated_rule_80_dispatch(precedence, allow_fallback)),
            81 => Some(self.parse_generated_rule_81_dispatch(precedence, allow_fallback)),
            82 => Some(self.parse_generated_rule_82_dispatch(precedence, allow_fallback)),
            83 => Some(self.parse_generated_rule_83_dispatch(precedence, allow_fallback)),
            84 => Some(self.parse_generated_rule_84_dispatch(precedence, allow_fallback)),
            85 => Some(self.parse_generated_rule_85_dispatch(precedence, allow_fallback)),
            86 => Some(self.parse_generated_rule_86_dispatch(precedence, allow_fallback)),
            87 => Some(self.parse_generated_rule_87_dispatch(precedence, allow_fallback)),
            88 => Some(self.parse_generated_rule_88_dispatch(precedence, allow_fallback)),
            89 => Some(self.parse_generated_rule_89_dispatch(precedence, allow_fallback)),
            90 => Some(self.parse_generated_rule_90_dispatch(precedence, allow_fallback)),
            91 => Some(self.parse_generated_rule_91_dispatch(precedence, allow_fallback)),
            92 => Some(self.parse_generated_rule_92_dispatch(precedence, allow_fallback)),
            93 => Some(self.parse_generated_rule_93_dispatch(precedence, allow_fallback)),
            94 => Some(self.parse_generated_rule_94_dispatch(precedence, allow_fallback)),
            95 => Some(self.parse_generated_rule_95_dispatch(precedence, allow_fallback)),
            96 => Some(self.parse_generated_rule_96_dispatch(precedence, allow_fallback)),
            97 => Some(self.parse_generated_rule_97_dispatch(precedence, allow_fallback)),
            98 => Some(self.parse_generated_rule_98_dispatch(precedence, allow_fallback)),
            99 => Some(self.parse_generated_rule_99_dispatch(precedence, allow_fallback)),
            100 => Some(self.parse_generated_rule_100_dispatch(precedence, allow_fallback)),
            101 if self.generated_only() || self.base.has_rule_depth_cap() || self.base.has_parse_listeners() || self.base.observes_parser_decisions() => Some(self.parse_generated_rule_101_dispatch(precedence, allow_fallback)),
            101 if !self.adaptive_atn_preferred_rules[0] => Some(self.parse_generated_rule_101_adaptive_dispatch(precedence, allow_fallback, None)),
            102 => Some(self.parse_generated_rule_102_dispatch(precedence, allow_fallback)),
            103 => Some(self.parse_generated_rule_103_dispatch(precedence, allow_fallback)),
            104 => Some(self.parse_generated_rule_104_dispatch(precedence, allow_fallback)),
            105 => Some(self.parse_generated_rule_105_dispatch(precedence, allow_fallback)),
            106 => Some(self.parse_generated_rule_106_dispatch(precedence, allow_fallback)),
            107 => Some(self.parse_generated_rule_107_dispatch(precedence, allow_fallback)),
            108 => Some(self.parse_generated_rule_108_dispatch(precedence, allow_fallback)),
            109 => Some(self.parse_generated_rule_109_dispatch(precedence, allow_fallback)),
            110 => Some(self.parse_generated_rule_110_dispatch(precedence, allow_fallback)),
            111 => Some(self.parse_generated_rule_111_dispatch(precedence, allow_fallback)),
            112 => Some(self.parse_generated_rule_112_dispatch(precedence, allow_fallback)),
            113 => Some(self.parse_generated_rule_113_dispatch(precedence, allow_fallback)),
            114 => Some(self.parse_generated_rule_114_dispatch(precedence, allow_fallback)),
            115 => Some(self.parse_generated_rule_115_dispatch(precedence, allow_fallback)),
            116 => Some(self.parse_generated_rule_116_dispatch(precedence, allow_fallback)),
            117 => Some(self.parse_generated_rule_117_dispatch(precedence, allow_fallback)),
            118 => Some(self.parse_generated_rule_118_dispatch(precedence, allow_fallback)),
            119 => Some(self.parse_generated_rule_119_dispatch(precedence, allow_fallback)),
            120 => Some(self.parse_generated_rule_120_dispatch(precedence, allow_fallback)),
            121 => Some(self.parse_generated_rule_121_dispatch(precedence, allow_fallback)),
            122 => Some(self.parse_generated_rule_122_dispatch(precedence, allow_fallback)),
            123 => Some(self.parse_generated_rule_123_dispatch(precedence, allow_fallback)),
            124 => Some(self.parse_generated_rule_124_dispatch(precedence, allow_fallback)),
            125 => Some(self.parse_generated_rule_125_dispatch(precedence, allow_fallback)),
            126 => Some(self.parse_generated_rule_126_dispatch(precedence, allow_fallback)),
            127 => Some(self.parse_generated_rule_127_dispatch(precedence, allow_fallback)),
            128 => Some(self.parse_generated_rule_128_dispatch(precedence, allow_fallback)),
            129 => Some(self.parse_generated_rule_129_dispatch(precedence, allow_fallback)),
            130 => Some(self.parse_generated_rule_130_dispatch(precedence, allow_fallback)),
            131 => Some(self.parse_generated_rule_131_dispatch(precedence, allow_fallback)),
            132 => Some(self.parse_generated_rule_132_dispatch(precedence, allow_fallback)),
            133 => Some(self.parse_generated_rule_133_dispatch(precedence, allow_fallback)),
            134 => Some(self.parse_generated_rule_134_dispatch(precedence, allow_fallback)),
            135 => Some(self.parse_generated_rule_135_dispatch(precedence, allow_fallback)),
            136 => Some(self.parse_generated_rule_136_dispatch(precedence, allow_fallback)),
            137 => Some(self.parse_generated_rule_137_dispatch(precedence, allow_fallback)),
            138 => Some(self.parse_generated_rule_138_dispatch(precedence, allow_fallback)),
            139 => Some(self.parse_generated_rule_139_dispatch(precedence, allow_fallback)),
            140 => Some(self.parse_generated_rule_140_dispatch(precedence, allow_fallback)),
            141 => Some(self.parse_generated_rule_141_dispatch(precedence, allow_fallback)),
            142 => Some(self.parse_generated_rule_142_dispatch(precedence, allow_fallback)),
            143 => Some(self.parse_generated_rule_143_dispatch(precedence, allow_fallback)),
            144 => Some(self.parse_generated_rule_144_dispatch(precedence, allow_fallback)),
            145 => Some(self.parse_generated_rule_145_dispatch(precedence, allow_fallback)),
            146 => Some(self.parse_generated_rule_146_dispatch(precedence, allow_fallback)),
            147 => Some(self.parse_generated_rule_147_dispatch(precedence, allow_fallback)),
            148 if self.generated_only() || self.base.has_rule_depth_cap() || self.base.has_parse_listeners() || self.base.observes_parser_decisions() => Some(self.parse_generated_rule_148_dispatch(precedence, allow_fallback)),
            148 if !self.adaptive_atn_preferred_rules[1] => Some(self.parse_generated_rule_148_adaptive_dispatch(precedence, allow_fallback, None)),
            149 => Some(self.parse_generated_rule_149_dispatch(precedence, allow_fallback)),
            150 => Some(self.parse_generated_rule_150_dispatch(precedence, allow_fallback)),
            151 => Some(self.parse_generated_rule_151_dispatch(precedence, allow_fallback)),
            152 => Some(self.parse_generated_rule_152_dispatch(precedence, allow_fallback)),
            153 => Some(self.parse_generated_rule_153_dispatch(precedence, allow_fallback)),
            154 => Some(self.parse_generated_rule_154_dispatch(precedence, allow_fallback)),
            155 => Some(self.parse_generated_rule_155_dispatch(precedence, allow_fallback)),
            156 => Some(self.parse_generated_rule_156_dispatch(precedence, allow_fallback)),
            157 => Some(self.parse_generated_rule_157_dispatch(precedence, allow_fallback)),
            158 => Some(self.parse_generated_rule_158_dispatch(precedence, allow_fallback)),
            159 => Some(self.parse_generated_rule_159_dispatch(precedence, allow_fallback)),
            160 => Some(self.parse_generated_rule_160_dispatch(precedence, allow_fallback)),
            161 => Some(self.parse_generated_rule_161_dispatch(precedence, allow_fallback)),
            162 => Some(self.parse_generated_rule_162_dispatch(precedence, allow_fallback)),
            163 => Some(self.parse_generated_rule_163_dispatch(precedence, allow_fallback)),
            164 => Some(self.parse_generated_rule_164_dispatch(precedence, allow_fallback)),
            165 => Some(self.parse_generated_rule_165_dispatch(precedence, allow_fallback)),
            166 => Some(self.parse_generated_rule_166_dispatch(precedence, allow_fallback)),
            167 => Some(self.parse_generated_rule_167_dispatch(precedence, allow_fallback)),
            168 => Some(self.parse_generated_rule_168_dispatch(precedence, allow_fallback)),
            169 => Some(self.parse_generated_rule_169_dispatch(precedence, allow_fallback)),
            170 => Some(self.parse_generated_rule_170_dispatch(precedence, allow_fallback)),
            171 => Some(self.parse_generated_rule_171_dispatch(precedence, allow_fallback)),
            172 => Some(self.parse_generated_rule_172_dispatch(precedence, allow_fallback)),
            173 => Some(self.parse_generated_rule_173_dispatch(precedence, allow_fallback)),
            174 => Some(self.parse_generated_rule_174_dispatch(precedence, allow_fallback)),
            175 => Some(self.parse_generated_rule_175_dispatch(precedence, allow_fallback)),
            176 => Some(self.parse_generated_rule_176_dispatch(precedence, allow_fallback)),
            177 => Some(self.parse_generated_rule_177_dispatch(precedence, allow_fallback)),
            178 => Some(self.parse_generated_rule_178_dispatch(precedence, allow_fallback)),
            179 => Some(self.parse_generated_rule_179_dispatch(precedence, allow_fallback)),
            180 => Some(self.parse_generated_rule_180_dispatch(precedence, allow_fallback)),
            181 => Some(self.parse_generated_rule_181_dispatch(precedence, allow_fallback)),
            182 => Some(self.parse_generated_rule_182_dispatch(precedence, allow_fallback)),
            183 => Some(self.parse_generated_rule_183_dispatch(precedence, allow_fallback)),
            184 => Some(self.parse_generated_rule_184_dispatch(precedence, allow_fallback)),
            185 => Some(self.parse_generated_rule_185_dispatch(precedence, allow_fallback)),
            186 => Some(self.parse_generated_rule_186_dispatch(precedence, allow_fallback)),
            187 => Some(self.parse_generated_rule_187_dispatch(precedence, allow_fallback)),
            188 => Some(self.parse_generated_rule_188_dispatch(precedence, allow_fallback)),
            189 => Some(self.parse_generated_rule_189_dispatch(precedence, allow_fallback)),
            190 => Some(self.parse_generated_rule_190_dispatch(precedence, allow_fallback)),
            191 => Some(self.parse_generated_rule_191_dispatch(precedence, allow_fallback)),
            192 => Some(self.parse_generated_rule_192_dispatch(precedence, allow_fallback)),
            193 => Some(self.parse_generated_rule_193_dispatch(precedence, allow_fallback)),
            194 => Some(self.parse_generated_rule_194_dispatch(precedence, allow_fallback)),
            195 => Some(self.parse_generated_rule_195_dispatch(precedence, allow_fallback)),
            196 => Some(self.parse_generated_rule_196_dispatch(precedence, allow_fallback)),
            197 => Some(self.parse_generated_rule_197_dispatch(precedence, allow_fallback)),
            198 => Some(self.parse_generated_rule_198_dispatch(precedence, allow_fallback)),
            199 => Some(self.parse_generated_rule_199_dispatch(precedence, allow_fallback)),
            200 => Some(self.parse_generated_rule_200_dispatch(precedence, allow_fallback)),
            201 => Some(self.parse_generated_rule_201_dispatch(precedence, allow_fallback)),
            202 => Some(self.parse_generated_rule_202_dispatch(precedence, allow_fallback)),
            203 => Some(self.parse_generated_rule_203_dispatch(precedence, allow_fallback)),
            204 => Some(self.parse_generated_rule_204_dispatch(precedence, allow_fallback)),
            205 => Some(self.parse_generated_rule_205_dispatch(precedence, allow_fallback)),
            206 => Some(self.parse_generated_rule_206_dispatch(precedence, allow_fallback)),
            207 => Some(self.parse_generated_rule_207_dispatch(precedence, allow_fallback)),
            208 => Some(self.parse_generated_rule_208_dispatch(precedence, allow_fallback)),
            209 => Some(self.parse_generated_rule_209_dispatch(precedence, allow_fallback)),
            210 => Some(self.parse_generated_rule_210_dispatch(precedence, allow_fallback)),
            211 => Some(self.parse_generated_rule_211_dispatch(precedence, allow_fallback)),
            212 => Some(self.parse_generated_rule_212_dispatch(precedence, allow_fallback)),
            213 => Some(self.parse_generated_rule_213_dispatch(precedence, allow_fallback)),
            214 => Some(self.parse_generated_rule_214_dispatch(precedence, allow_fallback)),
            215 => Some(self.parse_generated_rule_215_dispatch(precedence, allow_fallback)),
            216 => Some(self.parse_generated_rule_216_dispatch(precedence, allow_fallback)),
            217 => Some(self.parse_generated_rule_217_dispatch(precedence, allow_fallback)),
            218 => Some(self.parse_generated_rule_218_dispatch(precedence, allow_fallback)),
            219 => Some(self.parse_generated_rule_219_dispatch(precedence, allow_fallback)),
            220 => Some(self.parse_generated_rule_220_dispatch(precedence, allow_fallback)),
            221 => Some(self.parse_generated_rule_221_dispatch(precedence, allow_fallback)),
            222 => Some(self.parse_generated_rule_222_dispatch(precedence, allow_fallback)),
            223 => Some(self.parse_generated_rule_223_dispatch(precedence, allow_fallback)),
            224 => Some(self.parse_generated_rule_224_dispatch(precedence, allow_fallback)),
            225 => Some(self.parse_generated_rule_225_dispatch(precedence, allow_fallback)),
            226 => Some(self.parse_generated_rule_226_dispatch(precedence, allow_fallback)),
            227 => Some(self.parse_generated_rule_227_dispatch(precedence, allow_fallback)),
            228 => Some(self.parse_generated_rule_228_dispatch(precedence, allow_fallback)),
            229 => Some(self.parse_generated_rule_229_dispatch(precedence, allow_fallback)),
            230 => Some(self.parse_generated_rule_230_dispatch(precedence, allow_fallback)),
            231 => Some(self.parse_generated_rule_231_dispatch(precedence, allow_fallback)),
            232 => Some(self.parse_generated_rule_232_dispatch(precedence, allow_fallback)),
            233 => Some(self.parse_generated_rule_233_dispatch(precedence, allow_fallback)),
            234 => Some(self.parse_generated_rule_234_dispatch(precedence, allow_fallback)),
            235 => Some(self.parse_generated_rule_235_dispatch(precedence, allow_fallback)),
            236 => Some(self.parse_generated_rule_236_dispatch(precedence, allow_fallback)),
            237 => Some(self.parse_generated_rule_237_dispatch(precedence, allow_fallback)),
            238 => Some(self.parse_generated_rule_238_dispatch(precedence, allow_fallback)),
            239 => Some(self.parse_generated_rule_239_dispatch(precedence, allow_fallback)),
            240 => Some(self.parse_generated_rule_240_dispatch(precedence, allow_fallback)),
            241 => Some(self.parse_generated_rule_241_dispatch(precedence, allow_fallback)),
            242 => Some(self.parse_generated_rule_242_dispatch(precedence, allow_fallback)),
            243 => Some(self.parse_generated_rule_243_dispatch(precedence, allow_fallback)),
            _ => None,
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_0_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 0, GeneratedRuleError::Fatal; self.parse_generated_rule_0(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_0(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 0isize, 0, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_491 = false;
                loop {
                    match self.base.sync_decision(atn(), 491, !__ctx.has_matched_child(), __loop_iter_491) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 491) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(0, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(0, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 491, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_491 = true;
                            let __invoking_marker = self.base.push_invoking_state(488isize);
                            let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_497 = false;
                loop {
                    match self.base.sync_decision(atn(), 497, !__ctx.has_matched_child(), __loop_iter_497) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 497) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(1, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(1, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 497, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_497 = true;
                            let __invoking_marker = self.base.push_invoking_state(494isize);
                            let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_503 = false;
                loop {
                    match self.base.sync_decision(atn(), 503, !__ctx.has_matched_child(), __loop_iter_503) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 503) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(2, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(2, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 503, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_503 = true;
                            let __invoking_marker = self.base.push_invoking_state(500isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_509 = false;
                loop {
                    match self.base.sync_decision(atn(), 509, !__ctx.has_matched_child(), __loop_iter_509) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 509, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_509 = true;
                            let __invoking_marker = self.base.push_invoking_state(506isize);
                            let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(-1, 513, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_1_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 1, GeneratedRuleError::Fatal; self.parse_generated_rule_1(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_1(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 2isize, 1, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(41, 515, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(59, 516, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(516isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 518, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_2_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 2, GeneratedRuleError::Fatal; self.parse_generated_rule_2(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_2(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 4isize, 2, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 520, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    42 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    77 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 520, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(42, 521, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(77, 528, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 528, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 528) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(6, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(6, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 528, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(52, 529, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        match self.base.sync_decision(atn(), 525, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            57 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 525, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(57, 526, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __invoking_marker = self.base.push_invoking_state(527isize);
                        let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(530isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 532, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_3_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 3, GeneratedRuleError::Fatal; self.parse_generated_rule_3(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_3(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 6isize, 3, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(533isize);
                let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(169, 535, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_4_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 4, GeneratedRuleError::Fatal; self.parse_generated_rule_4(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_4(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 8isize, 4, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 538, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 538) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(7, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(7, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 538, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(42, 539, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(537isize);
                        let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_5_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 5, GeneratedRuleError::Fatal; self.parse_generated_rule_5(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_5(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 10isize, 5, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 542, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 542, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 542) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(8, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(8, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 542, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(541isize);
                        let __child = self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(544isize);
                let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_549 = false;
                loop {
                    match self.base.sync_decision(atn(), 549, !__ctx.has_matched_child(), __loop_iter_549) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 549, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_549 = true;
                            let __match = self.base.match_token_recovering(163, 546, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(546isize);
                            let __child = self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(203, 553, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_6_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 6, GeneratedRuleError::Fatal; self.parse_generated_rule_6(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_6(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 12isize, 6, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(554isize);
                let __child = self.parse_generated_rule_220_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 556, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_7_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 7, GeneratedRuleError::Fatal; self.parse_generated_rule_7(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_7(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 14isize, 7, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(557isize);
                let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 559, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 559, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(558isize);
                        let __child = self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_8_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 8, GeneratedRuleError::Fatal; self.parse_generated_rule_8_precedence(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_8(&mut self, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        self.parse_generated_rule_8_precedence(0, allow_fallback)
    }

    #[allow(dead_code)]
    fn parse_generated_rule_8_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! {
            recursive self, 16isize, 8, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 564, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 564) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction);
                match __prediction.alt {
                    1 => {
                        let action = self.base.parser_action_at_current_indexed(561, 8, 0, __rule_start, __consumed_eof);
                        let _ = action;
                        let __invoking_marker = self.base.push_invoking_state(562isize);
                        let __child = self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(563isize);
                        let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                loop {
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 571, __precedence) {
                        Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None },
                        Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        None => {
                            let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize };
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            match __simulator.adaptive_predict_stream_info_with_context(12, __prediction_precedence, self.base.input(), __prediction_context) {
                                Ok(__prediction) => __prediction,
                                Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None },
                                Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    };
                    let __prediction = if __prediction.alt == 1 {
                        let __semantic_la = self.base.la(1);
                        if __semantic_la == 165 {
                            __prediction
                        } else {
                            antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction }
                        }
                    } else {
                        __prediction
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 571, &__prediction);
                    match __prediction.alt {
                        1 => {
                            self.base.parse_listener_exit_rule(8);
                            if let Some(__depth_error) = self.base.rule_depth_cap_violation() {
                                return Err(__depth_error);
                            }
                            self.base.push_new_recursion_context_with_previous(16isize, 8, &mut __ctx);
                            if let Some(__listener_error) = self.base.parse_listener_enter_rule(8) {
                                return Err(__listener_error);
                            }
                            if !self.base.precpred(2) {
                                return Err(self.base.failed_predicate_error("precpred(_ctx, 2)"));
                            }
                            let __match = self.base.match_token_recovering(165, 568, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(568isize);
                            let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => break,
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_9_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 9, GeneratedRuleError::Fatal; self.parse_generated_rule_9(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_9(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 18isize, 9, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(574isize);
                let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(133, 576, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(576isize);
                let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_10_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 10, GeneratedRuleError::Fatal; self.parse_generated_rule_10(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_10(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 20isize, 10, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 580, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 580) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(13, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(13, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 580, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(578isize);
                        let __child = self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(579isize);
                        let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_11_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 11, GeneratedRuleError::Fatal; self.parse_generated_rule_11(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_11(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 22isize, 11, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(582isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(583isize);
                let __child = self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_12_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 12, GeneratedRuleError::Fatal; self.parse_generated_rule_12(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_12(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 24isize, 12, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(168, 598, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 598, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 598) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(17, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(17, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 598, &__prediction);
                match __prediction.alt {
                    1 => {
                        match self.base.sync_decision(atn(), 587, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 37..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            163 | 170 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 587, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(586isize);
                                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let mut __loop_iter_595 = false;
                        loop {
                            match self.base.sync_decision(atn(), 595, !__ctx.has_matched_child(), __loop_iter_595) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                170 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 595, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_595 = true;
                                    let __match = self.base.match_token_recovering(163, 591, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    match self.base.sync_decision(atn(), 591, !__ctx.has_matched_child(), false) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        Err(__error) => {
                                            __sync_error = Some(__error.clone());
                                            return Err(__error);
                                        }
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = match self.base.la(1) {
                                        4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 37..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        163 | 170 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    };
                                    self.base.record_generated_prediction_diagnostic(atn(), 591, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            let __invoking_marker = self.base.push_invoking_state(590isize);
                                            let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        2 => {
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(170, 601, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_13_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 13, GeneratedRuleError::Fatal; self.parse_generated_rule_13(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_13(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 26isize, 13, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 611, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 611, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 611, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(603isize);
                        let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_608 = false;
                        loop {
                            match self.base.sync_decision(atn(), 608, !__ctx.has_matched_child(), __loop_iter_608) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 608, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_608 = true;
                                    let __match = self.base.match_token_recovering(163, 605, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(605isize);
                                    let __child = self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 614, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_14_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 14, GeneratedRuleError::Fatal; self.parse_generated_rule_14(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_14(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 28isize, 14, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 621, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 621) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(22, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(22, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 621, &__prediction);
                match __prediction.alt {
                    1 => {
                        match self.base.sync_decision(atn(), 616, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 616) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(20, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(20, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 616, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(615isize);
                                let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        match self.base.sync_decision(atn(), 619, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 619) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(21, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(21, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 619, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(618isize);
                                let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(623isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(623isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_15_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 15, GeneratedRuleError::Fatal; self.parse_generated_rule_15(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_15(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 30isize, 15, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(625isize);
                let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 627, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_16_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 16, GeneratedRuleError::Fatal; self.parse_generated_rule_16(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_16(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 32isize, 16, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    19..=20 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 | 54 | 64 | 87 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5..=8 | 14 | 17 | 27 | 29 | 31 | 47 | 51 | 55..=56 | 62 | 67 | 74 | 77 | 79 | 81 | 90 | 94 | 96 | 98..=99 | 109 | 118 | 125 | 127 | 130 | 147..=148 | 156 | 160..=162 | 164..=165 | 167 | 172 | 178..=186 | 194..=197 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 639, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 639) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(23, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(23, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 639, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(628isize);
                        let __child = self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(629isize);
                        let __child = self.parse_generated_rule_71_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(630isize);
                        let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(631isize);
                        let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(632isize);
                        let __child = self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(633isize);
                        let __child = self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(634isize);
                        let __child = self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __invoking_marker = self.base.push_invoking_state(635isize);
                        let __child = self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __invoking_marker = self.base.push_invoking_state(636isize);
                        let __child = self.parse_generated_rule_74_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    10 => {
                        let __invoking_marker = self.base.push_invoking_state(637isize);
                        let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(638isize);
                        let __child = self.parse_generated_rule_75_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_17_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 17, GeneratedRuleError::Fatal; self.parse_generated_rule_17(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_17(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 34isize, 17, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 18 | 28 | 32..=33 | 37 | 39..=40 | 42..=43 | 46 | 50 | 53 | 58..=59 | 61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 89 | 91..=93 | 95 | 100..=103 | 107..=108 | 110..=112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 643, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 643) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(24, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(24, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 643, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(641isize);
                        let __child = self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(642isize);
                        let __child = self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_18_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 18, GeneratedRuleError::Fatal; self.parse_generated_rule_18(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_18(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 36isize, 18, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_648 = false;
                loop {
                    match self.base.sync_decision(atn(), 648, !__ctx.has_matched_child(), __loop_iter_648) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65..=66 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 648, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_648 = true;
                            let __invoking_marker = self.base.push_invoking_state(645isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_654 = false;
                loop {
                    match self.base.sync_decision(atn(), 654, !__ctx.has_matched_child(), __loop_iter_654) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        66 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 654, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_654 = true;
                            let __invoking_marker = self.base.push_invoking_state(651isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(66, 658, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(658isize);
                let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 660, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_19_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 19, GeneratedRuleError::Fatal; self.parse_generated_rule_19(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_19(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 38isize, 19, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_set_recovering(&[(13, 13), (16, 16), (21, 21), (23, 26), (34, 36), (38, 38), (41, 41), (45, 45), (48, 49), (52, 52), (57, 57), (60, 60), (65, 65), (69, 69), (88, 88), (97, 97), (113, 113), (116, 116)], 662, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_20_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 20, GeneratedRuleError::Fatal; self.parse_generated_rule_20(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_20(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 40isize, 20, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(663isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(664isize);
                let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_669 = false;
                loop {
                    match self.base.sync_decision(atn(), 669, !__ctx.has_matched_child(), __loop_iter_669) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        167 | 201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 669, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_669 = true;
                            let __match = self.base.match_token_recovering(163, 666, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(666isize);
                            let __child = self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_21_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 21, GeneratedRuleError::Fatal; self.parse_generated_rule_21(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_21(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 42isize, 21, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(672isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 674, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 167 | 169 | 201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 674, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(673isize);
                        let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 677, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    169 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 167 | 201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 677, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(676isize);
                        let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_22_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 22, GeneratedRuleError::Fatal; self.parse_generated_rule_22(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_22(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 44isize, 22, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 680, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(680isize);
                let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_685 = false;
                loop {
                    match self.base.sync_decision(atn(), 685, !__ctx.has_matched_child(), __loop_iter_685) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 685, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_685 = true;
                            let __match = self.base.match_token_recovering(163, 682, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(682isize);
                            let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(203, 689, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_23_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 23, GeneratedRuleError::Fatal; self.parse_generated_rule_23(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_23(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 46isize, 23, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 691, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 691) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(31, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(31, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 691, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(690isize);
                        let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 694, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 694) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(32, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(32, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 694, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_set_recovering(&[(115, 116), (149, 149)], 695, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(696isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(696isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_24_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 24, GeneratedRuleError::Fatal; self.parse_generated_rule_24(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_24(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 48isize, 24, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(169, 699, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(699isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(699isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_25_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 25, GeneratedRuleError::Fatal; self.parse_generated_rule_25(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_25(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 50isize, 25, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_704 = false;
                loop {
                    match self.base.sync_decision(atn(), 704, !__ctx.has_matched_child(), __loop_iter_704) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 704, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_704 = true;
                            let __invoking_marker = self.base.push_invoking_state(701isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_710 = false;
                loop {
                    match self.base.sync_decision(atn(), 710, !__ctx.has_matched_child(), __loop_iter_710) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 710) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(34, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(34, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 710, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_710 = true;
                            let __invoking_marker = self.base.push_invoking_state(707isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(713isize);
                let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 715, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_26_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 26, GeneratedRuleError::Fatal; self.parse_generated_rule_26(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_26(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 52isize, 26, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    19..=20 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    175 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 721, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 721) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(35, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(35, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 721, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(716isize);
                        let __child = self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(717isize);
                        let __child = self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(718isize);
                        let __child = self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(719isize);
                        let __child = self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(720isize);
                        let __child = self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_27_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 27, GeneratedRuleError::Fatal; self.parse_generated_rule_27(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_27(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 54isize, 27, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_726 = false;
                loop {
                    match self.base.sync_decision(atn(), 726, !__ctx.has_matched_child(), __loop_iter_726) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 21 | 23..=26 | 32..=38 | 40..=42 | 45..=46 | 48..=50 | 52 | 57 | 59..=61 | 65 | 68..=69 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 726, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_726 = true;
                            let __invoking_marker = self.base.push_invoking_state(723isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_732 = false;
                loop {
                    match self.base.sync_decision(atn(), 732, !__ctx.has_matched_child(), __loop_iter_732) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 732) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(37, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(37, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 732, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_732 = true;
                            let __invoking_marker = self.base.push_invoking_state(729isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(735isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(736isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 738, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 | 167 | 197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 738, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(737isize);
                        let __child = self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 745, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 745, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(740isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(741isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 743, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 746, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_28_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 28, GeneratedRuleError::Fatal; self.parse_generated_rule_28(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_28(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 56isize, 28, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 756, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 756, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 756) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(41, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(41, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 756, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(748isize);
                        let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_753 = false;
                        loop {
                            match self.base.sync_decision(atn(), 753, !__ctx.has_matched_child(), __loop_iter_753) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 753, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_753 = true;
                                    let __match = self.base.match_token_recovering(163, 750, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(750isize);
                                    let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 759, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_29_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 29, GeneratedRuleError::Fatal; self.parse_generated_rule_29(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_29(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 58isize, 29, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_763 = false;
                loop {
                    match self.base.sync_decision(atn(), 763, !__ctx.has_matched_child(), __loop_iter_763) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 6 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97..=98 | 100..=103 | 107..=108 | 110..=117 | 119 | 141 | 146 | 149 | 151..=153 | 163 | 169 | 173 | 176..=177 | 200..=201 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 763, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_763 = true;
                            let __invoking_marker = self.base.push_invoking_state(760isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_773 = false;
                loop {
                    match self.base.sync_decision(atn(), 773, !__ctx.has_matched_child(), __loop_iter_773) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 773) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 773, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_773 = true;
                            let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                115 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                149 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                98 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => {
                                    match self.base.sync_decision(atn(), 771, !__ctx.has_matched_child(), false) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        Err(__error) => {
                                            __sync_error = Some(__error.clone());
                                            return Err(__error);
                                        }
                                    }
                                    __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    match self.base.la(1) {
                                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        115 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        149 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        44 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        98 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 771, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    let __invoking_marker = self.base.push_invoking_state(766isize);
                                    let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    let __match = self.base.match_token_recovering(115, 772, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                3 => {
                                    let __match = self.base.match_token_recovering(149, 772, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                4 => {
                                    let __match = self.base.match_token_recovering(44, 772, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                5 => {
                                    let __match = self.base.match_token_recovering(98, 772, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 777, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 777) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(45, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(45, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 777, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(776isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 781, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    6 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 169 | 201 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 781, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(779isize);
                        let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(6, 782, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 784, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    169 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 201 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 784, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(783isize);
                        let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_30_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 30, GeneratedRuleError::Fatal; self.parse_generated_rule_30(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_30(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 60isize, 30, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(199, 787, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_set_recovering(&[(81, 81), (98, 98)], 788, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(788isize);
                let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_31_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 31, GeneratedRuleError::Fatal; self.parse_generated_rule_31(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_31(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 62isize, 31, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 799, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 799, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 149 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 799, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(791isize);
                        let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_796 = false;
                        loop {
                            match self.base.sync_decision(atn(), 796, !__ctx.has_matched_child(), __loop_iter_796) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 796, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_796 = true;
                                    let __match = self.base.match_token_recovering(163, 793, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(793isize);
                                    let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 802, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_32_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 32, GeneratedRuleError::Fatal; self.parse_generated_rule_32(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_32(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 64isize, 32, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_806 = false;
                loop {
                    match self.base.sync_decision(atn(), 806, !__ctx.has_matched_child(), __loop_iter_806) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        197 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 806, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_806 = true;
                            let __invoking_marker = self.base.push_invoking_state(803isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(197, 813, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_813 = false;
                loop {
                    match self.base.sync_decision(atn(), 813, !__ctx.has_matched_child(), __loop_iter_813) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        3..=10 | 13..=18 | 21 | 23..=29 | 31..=43 | 45..=53 | 55..=62 | 65 | 67..=83 | 85 | 88..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 813, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_813 = true;
                            let __invoking_marker = self.base.push_invoking_state(810isize);
                            let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(198, 817, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_33_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 33, GeneratedRuleError::Fatal; self.parse_generated_rule_33(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_33(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 66isize, 33, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(138, 819, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(819isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(819isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_34_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 34, GeneratedRuleError::Fatal; self.parse_generated_rule_34(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_34(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 68isize, 34, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_824 = false;
                loop {
                    match self.base.sync_decision(atn(), 824, !__ctx.has_matched_child(), __loop_iter_824) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 19..=21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 824, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_824 = true;
                            let __invoking_marker = self.base.push_invoking_state(821isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_830 = false;
                loop {
                    match self.base.sync_decision(atn(), 830, !__ctx.has_matched_child(), __loop_iter_830) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        19..=20 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 830, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_830 = true;
                            let __invoking_marker = self.base.push_invoking_state(827isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_set_recovering(&[(19, 20)], 835, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 835, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    22 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 835, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(834isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(22, 839, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 839, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 37..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 839, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(27, 840, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(841isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(842isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 848, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 848, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(843isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(844isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 846, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 849, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_35_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 35, GeneratedRuleError::Fatal; self.parse_generated_rule_35(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_35(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 70isize, 35, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(850isize);
                let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(165, 852, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_36_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 36, GeneratedRuleError::Fatal; self.parse_generated_rule_36(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_36(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 72isize, 36, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_856 = false;
                loop {
                    match self.base.sync_decision(atn(), 856, !__ctx.has_matched_child(), __loop_iter_856) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 | 175 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 856, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_856 = true;
                            let __invoking_marker = self.base.push_invoking_state(853isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_862 = false;
                loop {
                    match self.base.sync_decision(atn(), 862, !__ctx.has_matched_child(), __loop_iter_862) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        175 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 862, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_862 = true;
                            let __invoking_marker = self.base.push_invoking_state(859isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(175, 866, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(866isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(867isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 873, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 873, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(868isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(869isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 871, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 874, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_37_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 37, GeneratedRuleError::Fatal; self.parse_generated_rule_37(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 74isize, 37, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_878 = false;
                loop {
                    match self.base.sync_decision(atn(), 878, !__ctx.has_matched_child(), __loop_iter_878) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 878, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_878 = true;
                            let __invoking_marker = self.base.push_invoking_state(875isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_884 = false;
                loop {
                    match self.base.sync_decision(atn(), 884, !__ctx.has_matched_child(), __loop_iter_884) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 884) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(61, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(61, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 884, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_884 = true;
                            let __invoking_marker = self.base.push_invoking_state(881isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(887isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 889, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 889) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(62, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(62, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 889, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(888isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(891isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 893, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 893, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(892isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(895isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_899 = false;
                loop {
                    match self.base.sync_decision(atn(), 899, !__ctx.has_matched_child(), __loop_iter_899) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        78 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        138 | 167 | 197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 899, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_899 = true;
                            let __invoking_marker = self.base.push_invoking_state(896isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 907, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 907, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(902isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(903isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 905, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 908, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_38_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 38, GeneratedRuleError::Fatal; self.parse_generated_rule_38(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_38(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 76isize, 38, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(168, 910, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(910isize);
                let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_915 = false;
                loop {
                    match self.base.sync_decision(atn(), 915, !__ctx.has_matched_child(), __loop_iter_915) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        170 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 915, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_915 = true;
                            let __match = self.base.match_token_recovering(163, 912, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(912isize);
                            let __child = self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(170, 919, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_39_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 39, GeneratedRuleError::Fatal; self.parse_generated_rule_39(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_39(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 78isize, 39, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_923 = false;
                loop {
                    match self.base.sync_decision(atn(), 923, !__ctx.has_matched_child(), __loop_iter_923) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114..=115 | 117 | 119 | 141 | 146 | 149 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 923, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_923 = true;
                            let __invoking_marker = self.base.push_invoking_state(920isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 927, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    115 | 149 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 927, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_set_recovering(&[(115, 115), (149, 149)], 928, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(929isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_40_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 40, GeneratedRuleError::Fatal; self.parse_generated_rule_40(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_40(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 80isize, 40, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(78, 932, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(932isize);
                let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 934, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(934isize);
                let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_939 = false;
                loop {
                    match self.base.sync_decision(atn(), 939, !__ctx.has_matched_child(), __loop_iter_939) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 138 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 939, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_939 = true;
                            let __match = self.base.match_token_recovering(163, 936, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(936isize);
                            let __child = self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_41_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 41, GeneratedRuleError::Fatal; self.parse_generated_rule_41(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 82isize, 41, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    54 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    113 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 38..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 947, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 947) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(70, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(70, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 947, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(942isize);
                        let __child = self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(943isize);
                        let __child = self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(944isize);
                        let __child = self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(945isize);
                        let __child = self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(946isize);
                        let __child = self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_42_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 42, GeneratedRuleError::Fatal; self.parse_generated_rule_42(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 84isize, 42, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(37, 950, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(950isize);
                let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_955 = false;
                loop {
                    match self.base.sync_decision(atn(), 955, !__ctx.has_matched_child(), __loop_iter_955) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 955) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(71, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(71, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 955, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_955 = true;
                            let __match = self.base.match_token_recovering(163, 952, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(952isize);
                            let __child = self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_43_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 43, GeneratedRuleError::Fatal; self.parse_generated_rule_43(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_43(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 86isize, 43, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(958isize);
                let __child = self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_44_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 44, GeneratedRuleError::Fatal; self.parse_generated_rule_44(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_44(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 88isize, 44, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(116, 961, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(54, 962, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_45_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 45, GeneratedRuleError::Fatal; self.parse_generated_rule_45(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_45(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 90isize, 45, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    54 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 971, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            54 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 971, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(64, 965, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 965, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            171 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 138 | 141 | 146..=148 | 151..=153 | 156 | 160..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 965, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(171, 966, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(54, 969, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 969, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            171 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 138 | 141 | 146..=148 | 151..=153 | 156 | 160..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 969, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(171, 970, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_46_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 46, GeneratedRuleError::Fatal; self.parse_generated_rule_46(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_46(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 92isize, 46, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 974, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 975, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(201, 976, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_47_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 47, GeneratedRuleError::Fatal; self.parse_generated_rule_47(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_47(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 94isize, 47, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(29, 978, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_48_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 48, GeneratedRuleError::Fatal; self.parse_generated_rule_48(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_48(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 96isize, 48, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(979isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_49_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 49, GeneratedRuleError::Fatal; self.parse_generated_rule_49(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_49(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 98isize, 49, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_984 = false;
                loop {
                    match self.base.sync_decision(atn(), 984, !__ctx.has_matched_child(), __loop_iter_984) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 984, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_984 = true;
                            let __invoking_marker = self.base.push_invoking_state(981isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_990 = false;
                loop {
                    match self.base.sync_decision(atn(), 990, !__ctx.has_matched_child(), __loop_iter_990) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 990) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(76, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(76, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 990, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_990 = true;
                            let __invoking_marker = self.base.push_invoking_state(987isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(993isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 995, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    22 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 995, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(994isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(22, 999, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 999, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    67 | 99 | 105 | 120..=121 | 123..=128 | 131 | 135..=137 | 139 | 144 | 150 | 154 | 156 | 159..=162 | 164 | 166 | 168 | 170 | 172 | 174..=175 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 999, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(27, 1000, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    162 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    164 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    156 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    175 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    125 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    127 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    161 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    166 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    159 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    135 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    174 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    160 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    172 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    137 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    120 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    136 => antlr4_runtime::ParserAtnPrediction { alt: 19, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    139 => antlr4_runtime::ParserAtnPrediction { alt: 21, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    67 => antlr4_runtime::ParserAtnPrediction { alt: 22, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    99 => antlr4_runtime::ParserAtnPrediction { alt: 23, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    150 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    126 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    128 => antlr4_runtime::ParserAtnPrediction { alt: 26, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 27, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    131 => antlr4_runtime::ParserAtnPrediction { alt: 28, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    121 => antlr4_runtime::ParserAtnPrediction { alt: 29, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    123 => antlr4_runtime::ParserAtnPrediction { alt: 30, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    154 => antlr4_runtime::ParserAtnPrediction { alt: 31, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    144 => antlr4_runtime::ParserAtnPrediction { alt: 32, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    105 => antlr4_runtime::ParserAtnPrediction { alt: 33, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1036, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1036) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(79, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(79, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1036, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(162, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(164, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(156, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(175, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(125, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        let __match = self.base.match_token_recovering(127, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        let __match = self.base.match_token_recovering(161, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    8 => {
                        let __match = self.base.match_token_recovering(166, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    9 => {
                        let __match = self.base.match_token_recovering(159, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    10 => {
                        let __match = self.base.match_token_recovering(135, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(1011isize);
                        let __child = self.parse_generated_rule_238_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    12 => {
                        let __invoking_marker = self.base.push_invoking_state(1012isize);
                        let __child = self.parse_generated_rule_239_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    13 => {
                        let __match = self.base.match_token_recovering(174, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    14 => {
                        let __match = self.base.match_token_recovering(160, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    15 => {
                        let __match = self.base.match_token_recovering(172, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    16 => {
                        let __match = self.base.match_token_recovering(137, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    17 => {
                        let __match = self.base.match_token_recovering(120, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    18 => {
                        let __match = self.base.match_token_recovering(168, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    19 => {
                        let __match = self.base.match_token_recovering(136, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    20 => {
                        let __match = self.base.match_token_recovering(170, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    21 => {
                        let __match = self.base.match_token_recovering(139, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    22 => {
                        let __match = self.base.match_token_recovering(67, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    23 => {
                        let __match = self.base.match_token_recovering(99, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    24 => {
                        let __match = self.base.match_token_recovering(150, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    25 => {
                        let __match = self.base.match_token_recovering(126, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    26 => {
                        let __match = self.base.match_token_recovering(128, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    27 => {
                        let __match = self.base.match_token_recovering(124, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    28 => {
                        let __match = self.base.match_token_recovering(131, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    29 => {
                        let __match = self.base.match_token_recovering(121, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    30 => {
                        let __match = self.base.match_token_recovering(123, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    31 => {
                        let __match = self.base.match_token_recovering(154, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    32 => {
                        let __match = self.base.match_token_recovering(144, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    33 => {
                        let __match = self.base.match_token_recovering(105, 1037, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    34 => {
                        let __invoking_marker = self.base.push_invoking_state(1034isize);
                        let __child = self.parse_generated_rule_240_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    35 => {
                        let __invoking_marker = self.base.push_invoking_state(1035isize);
                        let __child = self.parse_generated_rule_241_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1038isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1044, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1044, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1039isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1040isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 1042, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 1045, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_50_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 50, GeneratedRuleError::Fatal; self.parse_generated_rule_50(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 100isize, 50, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 1048, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1048) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(81, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(81, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1048, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1046isize);
                        let __child = self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1047isize);
                        let __child = self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_51_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 51, GeneratedRuleError::Fatal; self.parse_generated_rule_51(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_51(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 102isize, 51, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1053 = false;
                loop {
                    match self.base.sync_decision(atn(), 1053, !__ctx.has_matched_child(), __loop_iter_1053) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        12..=13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1053, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1053 = true;
                            let __invoking_marker = self.base.push_invoking_state(1050isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1059 = false;
                loop {
                    match self.base.sync_decision(atn(), 1059, !__ctx.has_matched_child(), __loop_iter_1059) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1059, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1059 = true;
                            let __invoking_marker = self.base.push_invoking_state(1056isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(12, 1063, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1063isize);
                let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 1068, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_1068 = false;
                loop {
                    match self.base.sync_decision(atn(), 1068, !__ctx.has_matched_child(), __loop_iter_1068) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1068) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(84, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(84, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1068, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1068 = true;
                            let __invoking_marker = self.base.push_invoking_state(1065isize);
                            let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1074 = false;
                loop {
                    match self.base.sync_decision(atn(), 1074, !__ctx.has_matched_child(), __loop_iter_1074) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1074) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(85, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(85, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1074, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1074 = true;
                            let __invoking_marker = self.base.push_invoking_state(1071isize);
                            let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1080 = false;
                loop {
                    match self.base.sync_decision(atn(), 1080, !__ctx.has_matched_child(), __loop_iter_1080) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1080) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(86, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(86, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1080, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1080 = true;
                            let __invoking_marker = self.base.push_invoking_state(1077isize);
                            let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_52_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 52, GeneratedRuleError::Fatal; self.parse_generated_rule_52(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_52(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 104isize, 52, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1086 = false;
                loop {
                    match self.base.sync_decision(atn(), 1086, !__ctx.has_matched_child(), __loop_iter_1086) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        12..=13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1086, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1086 = true;
                            let __invoking_marker = self.base.push_invoking_state(1083isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1092 = false;
                loop {
                    match self.base.sync_decision(atn(), 1092, !__ctx.has_matched_child(), __loop_iter_1092) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1092, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1092 = true;
                            let __invoking_marker = self.base.push_invoking_state(1089isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(12, 1096, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1096isize);
                let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(197, 1101, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_1101 = false;
                loop {
                    match self.base.sync_decision(atn(), 1101, !__ctx.has_matched_child(), __loop_iter_1101) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1101) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(89, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(89, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1101, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1101 = true;
                            let __invoking_marker = self.base.push_invoking_state(1098isize);
                            let __child = self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1107 = false;
                loop {
                    match self.base.sync_decision(atn(), 1107, !__ctx.has_matched_child(), __loop_iter_1107) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1107) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(90, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(90, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1107, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1107 = true;
                            let __invoking_marker = self.base.push_invoking_state(1104isize);
                            let __child = self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1113 = false;
                loop {
                    match self.base.sync_decision(atn(), 1113, !__ctx.has_matched_child(), __loop_iter_1113) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1113, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1113 = true;
                            let __invoking_marker = self.base.push_invoking_state(1110isize);
                            let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(198, 1118, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1118, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1118) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(92, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(92, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1118, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1119, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_53_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 53, GeneratedRuleError::Fatal; self.parse_generated_rule_53(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_53(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 106isize, 53, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1123, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1123) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(93, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(93, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1123, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1120isize);
                        let __child = self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1121isize);
                        let __child = self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(1122isize);
                        let __child = self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_54_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 54, GeneratedRuleError::Fatal; self.parse_generated_rule_54(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_54(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 108isize, 54, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1128 = false;
                loop {
                    match self.base.sync_decision(atn(), 1128, !__ctx.has_matched_child(), __loop_iter_1128) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65..=66 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1128, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1128 = true;
                            let __invoking_marker = self.base.push_invoking_state(1125isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1134 = false;
                loop {
                    match self.base.sync_decision(atn(), 1134, !__ctx.has_matched_child(), __loop_iter_1134) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        66 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1134, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1134 = true;
                            let __invoking_marker = self.base.push_invoking_state(1131isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(66, 1138, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1138isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1140, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1140) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(96, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(96, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1140, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1139isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1142isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1145, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1145, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1143isize);
                        let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(167, 1146, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_55_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 55, GeneratedRuleError::Fatal; self.parse_generated_rule_55(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 110isize, 55, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(197, 1151, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_1151 = false;
                loop {
                    match self.base.sync_decision(atn(), 1151, !__ctx.has_matched_child(), __loop_iter_1151) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45..=46 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 91 | 97 | 107 | 110 | 113 | 116..=117 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1151, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1151 = true;
                            let __invoking_marker = self.base.push_invoking_state(1148isize);
                            let __child = self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(198, 1155, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_56_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 56, GeneratedRuleError::Fatal; self.parse_generated_rule_56(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_56(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 112isize, 56, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1159 = false;
                loop {
                    match self.base.sync_decision(atn(), 1159, !__ctx.has_matched_child(), __loop_iter_1159) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45..=46 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 91 | 97 | 107 | 110 | 113 | 116..=117 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1159, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1159 = true;
                            let __invoking_marker = self.base.push_invoking_state(1156isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1165 = false;
                loop {
                    match self.base.sync_decision(atn(), 1165, !__ctx.has_matched_child(), __loop_iter_1165) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        46 | 91 | 107 | 110 | 117 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1165, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1165 = true;
                            let __invoking_marker = self.base.push_invoking_state(1162isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_set_recovering(&[(46, 46), (91, 91), (107, 107), (110, 110), (117, 117)], 1174, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1174, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1174, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1169isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1170isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 1172, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(167, 1175, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_57_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 57, GeneratedRuleError::Fatal; self.parse_generated_rule_57(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_57(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 114isize, 57, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1179 = false;
                loop {
                    match self.base.sync_decision(atn(), 1179, !__ctx.has_matched_child(), __loop_iter_1179) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1179, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1179 = true;
                            let __invoking_marker = self.base.push_invoking_state(1176isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1185 = false;
                loop {
                    match self.base.sync_decision(atn(), 1185, !__ctx.has_matched_child(), __loop_iter_1185) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1185) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(103, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(103, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1185, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1185 = true;
                            let __invoking_marker = self.base.push_invoking_state(1182isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1188isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1190, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    98 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1190, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1189isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(98, 1193, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1193isize);
                let __child = self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1198, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1198, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1194isize);
                        let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1195isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 1197, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_58_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 58, GeneratedRuleError::Fatal; self.parse_generated_rule_58(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_58(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 116isize, 58, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 1201, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1201isize);
                let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1206 = false;
                loop {
                    match self.base.sync_decision(atn(), 1206, !__ctx.has_matched_child(), __loop_iter_1206) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1206, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1206 = true;
                            let __match = self.base.match_token_recovering(163, 1203, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(1203isize);
                            let __child = self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(203, 1210, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_59_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 59, GeneratedRuleError::Fatal; self.parse_generated_rule_59(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_59(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 118isize, 59, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1214 = false;
                loop {
                    match self.base.sync_decision(atn(), 1214, !__ctx.has_matched_child(), __loop_iter_1214) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1214, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1214 = true;
                            let __invoking_marker = self.base.push_invoking_state(1211isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1220 = false;
                loop {
                    match self.base.sync_decision(atn(), 1220, !__ctx.has_matched_child(), __loop_iter_1220) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1220) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(108, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(108, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1220, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1220 = true;
                            let __invoking_marker = self.base.push_invoking_state(1217isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1223isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1225, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1225) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(109, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(109, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1225, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1224isize);
                        let __child = self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1227isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 | 169 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1240, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 | 169 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1240, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1228isize);
                        let __child = self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        match self.base.sync_decision(atn(), 1232, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            169 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1232, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1229isize);
                                let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                                let __match = self.base.match_token_recovering(167, 1231, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            169 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1236, !__ctx.has_matched_child(), false) {
                                    Ok(__sync_children) => {
                                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                    }
                                    Err(__error) => {
                                        __sync_error = Some(__error.clone());
                                        return Err(__error);
                                    }
                                }
                                __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                match self.base.la(1) {
                                    138 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    169 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1236, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1234isize);
                                let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                                let __invoking_marker = self.base.push_invoking_state(1235isize);
                                let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(167, 1239, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_60_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 60, GeneratedRuleError::Fatal; self.parse_generated_rule_60(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_60(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 120isize, 60, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    87 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    10..=11 | 54 | 64 | 76 | 176 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1244, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1244) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(113, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(113, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1244, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1242isize);
                        let __child = self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1243isize);
                        let __child = self.parse_generated_rule_67_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_61_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 61, GeneratedRuleError::Fatal; self.parse_generated_rule_61(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_61(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 122isize, 61, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1249 = false;
                loop {
                    match self.base.sync_decision(atn(), 1249, !__ctx.has_matched_child(), __loop_iter_1249) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 87..=88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1249, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1249 = true;
                            let __invoking_marker = self.base.push_invoking_state(1246isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1255 = false;
                loop {
                    match self.base.sync_decision(atn(), 1255, !__ctx.has_matched_child(), __loop_iter_1255) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        87 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1255, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1255 = true;
                            let __invoking_marker = self.base.push_invoking_state(1252isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(87, 1259, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1259isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1261, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1261, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1260isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1278, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1278) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(120, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(120, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1278, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1275, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 1275, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            4 | 9..=10 | 13 | 15..=16 | 21 | 23..=26 | 32..=38 | 40..=42 | 45..=46 | 48..=50 | 52 | 57 | 59..=61 | 65 | 68..=69 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1275, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1264isize);
                                let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                                let mut __loop_iter_1269 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 1269, !__ctx.has_matched_child(), __loop_iter_1269) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        Err(__error) => {
                                            __sync_error = Some(__error.clone());
                                            return Err(__error);
                                        }
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1269) {
                                        __prediction
                                    } else {
                                        let __prediction = {
                                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                            __simulator.adaptive_predict_stream_info_sll_probe(117, 0, self.base.input())
                                                .map_err(|__error| match __error {
                                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                                })?
                                        };
                                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                            __simulator.adaptive_predict_stream_info_with_context(117, 0, self.base.input(), __prediction_context)
                                                .map_err(|__error| match __error {
                                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                                })?
                                        } else {
                                            __prediction
                                        }
                                    };
                                    self.base.record_generated_prediction_diagnostic(atn(), 1269, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1269 = true;
                                            let __match = self.base.match_token_recovering(163, 1266, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                            let __invoking_marker = self.base.push_invoking_state(1266isize);
                                            let __child = self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        2 => {
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                match self.base.sync_decision(atn(), 1273, !__ctx.has_matched_child(), false) {
                                    Ok(__sync_children) => {
                                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                    }
                                    Err(__error) => {
                                        __sync_error = Some(__error.clone());
                                        return Err(__error);
                                    }
                                }
                                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                let __prediction = match self.base.la(1) {
                                    163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                };
                                self.base.record_generated_prediction_diagnostic(atn(), 1273, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        let __match = self.base.match_token_recovering(163, 1274, atn())?;
                                        __consumed_eof |= __match.consumed_eof();
                                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    }
                                    2 => {
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(198, 1279, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1281, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1281) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(121, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(121, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1281, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1282, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_62_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 62, GeneratedRuleError::Fatal; self.parse_generated_rule_62(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_62(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 124isize, 62, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(199, 1284, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1284isize);
                let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1289 = false;
                loop {
                    match self.base.sync_decision(atn(), 1289, !__ctx.has_matched_child(), __loop_iter_1289) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1289, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1289 = true;
                            let __match = self.base.match_token_recovering(163, 1286, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(1286isize);
                            let __child = self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_63_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 63, GeneratedRuleError::Fatal; self.parse_generated_rule_63(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_63(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 126isize, 63, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 1294, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1294) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(123, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(123, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1294, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1292isize);
                        let __child = self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1293isize);
                        let __child = self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_64_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 64, GeneratedRuleError::Fatal; self.parse_generated_rule_64(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_64(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 128isize, 64, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(1296isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(1297isize);
                let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_65_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 65, GeneratedRuleError::Fatal; self.parse_generated_rule_65(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_65(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 130isize, 65, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(1299isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_66_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 66, GeneratedRuleError::Fatal; self.parse_generated_rule_66(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_66(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 132isize, 66, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1304 = false;
                loop {
                    match self.base.sync_decision(atn(), 1304, !__ctx.has_matched_child(), __loop_iter_1304) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 21 | 23..=26 | 32..=38 | 40..=42 | 45..=46 | 48..=50 | 52 | 57 | 59..=61 | 65 | 68..=69 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1304, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1304 = true;
                            let __invoking_marker = self.base.push_invoking_state(1301isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1310 = false;
                loop {
                    match self.base.sync_decision(atn(), 1310, !__ctx.has_matched_child(), __loop_iter_1310) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1310) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(125, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(125, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1310, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1310 = true;
                            let __invoking_marker = self.base.push_invoking_state(1307isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1313isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1315, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    169 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1315, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1314isize);
                        let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_67_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 67, GeneratedRuleError::Fatal; self.parse_generated_rule_67(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_67(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 134isize, 67, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    176 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    54 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    76 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1323, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1323) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(127, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(127, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1323, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1317isize);
                        let __child = self.parse_generated_rule_68_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1318isize);
                        let __child = self.parse_generated_rule_69_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(1319isize);
                        let __child = self.parse_generated_rule_70_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(1320isize);
                        let __child = self.parse_generated_rule_71_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(1321isize);
                        let __child = self.parse_generated_rule_72_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(1322isize);
                        let __child = self.parse_generated_rule_73_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_68_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 68, GeneratedRuleError::Fatal; self.parse_generated_rule_68(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_68(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 136isize, 68, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1328 = false;
                loop {
                    match self.base.sync_decision(atn(), 1328, !__ctx.has_matched_child(), __loop_iter_1328) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 64..=65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1328, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1328 = true;
                            let __invoking_marker = self.base.push_invoking_state(1325isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1334 = false;
                loop {
                    match self.base.sync_decision(atn(), 1334, !__ctx.has_matched_child(), __loop_iter_1334) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1334, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1334 = true;
                            let __invoking_marker = self.base.push_invoking_state(1331isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(64, 1338, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1338isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1340, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1340, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1339isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1343, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1343) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(131, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(131, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1343, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1342isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1346, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1346, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1345isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1351 = false;
                loop {
                    match self.base.sync_decision(atn(), 1351, !__ctx.has_matched_child(), __loop_iter_1351) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1351) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(133, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(133, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1351, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1351 = true;
                            let __invoking_marker = self.base.push_invoking_state(1348isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1362, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1362) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(135, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(135, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1362, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1358, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_1358 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1358, !__ctx.has_matched_child(), __loop_iter_1358) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1358, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1358 = true;
                                    let __invoking_marker = self.base.push_invoking_state(1355isize);
                                    let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(198, 1363, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1365, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1365) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(136, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(136, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1365, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1366, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_69_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 69, GeneratedRuleError::Fatal; self.parse_generated_rule_69(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_69(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 138isize, 69, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1370 = false;
                loop {
                    match self.base.sync_decision(atn(), 1370, !__ctx.has_matched_child(), __loop_iter_1370) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        10 | 13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1370, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1370 = true;
                            let __invoking_marker = self.base.push_invoking_state(1367isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1376 = false;
                loop {
                    match self.base.sync_decision(atn(), 1376, !__ctx.has_matched_child(), __loop_iter_1376) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        10 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1376, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1376 = true;
                            let __invoking_marker = self.base.push_invoking_state(1373isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(10, 1381, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1381, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    78 | 197 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1381, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1380isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1384, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    78 | 197 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1384, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1383isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1389 = false;
                loop {
                    match self.base.sync_decision(atn(), 1389, !__ctx.has_matched_child(), __loop_iter_1389) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        78 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        197 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1389, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1389 = true;
                            let __invoking_marker = self.base.push_invoking_state(1386isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(197, 1396, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_1396 = false;
                loop {
                    match self.base.sync_decision(atn(), 1396, !__ctx.has_matched_child(), __loop_iter_1396) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1396, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1396 = true;
                            let __invoking_marker = self.base.push_invoking_state(1393isize);
                            let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(198, 1400, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_70_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 70, GeneratedRuleError::Fatal; self.parse_generated_rule_70(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_70(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 140isize, 70, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1404 = false;
                loop {
                    match self.base.sync_decision(atn(), 1404, !__ctx.has_matched_child(), __loop_iter_1404) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        11 | 13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1404, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1404 = true;
                            let __invoking_marker = self.base.push_invoking_state(1401isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1410 = false;
                loop {
                    match self.base.sync_decision(atn(), 1410, !__ctx.has_matched_child(), __loop_iter_1410) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1410, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1410 = true;
                            let __invoking_marker = self.base.push_invoking_state(1407isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(11, 1414, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1414isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1416, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1416, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1415isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1419, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1419) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(146, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(146, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1419, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1418isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1422, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1422, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1421isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1427 = false;
                loop {
                    match self.base.sync_decision(atn(), 1427, !__ctx.has_matched_child(), __loop_iter_1427) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1427) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(148, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(148, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1427, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1427 = true;
                            let __invoking_marker = self.base.push_invoking_state(1424isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1438, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1438) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(150, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(150, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1438, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1434, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_1434 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1434, !__ctx.has_matched_child(), __loop_iter_1434) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1434, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1434 = true;
                                    let __invoking_marker = self.base.push_invoking_state(1431isize);
                                    let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(198, 1439, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1441, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1441) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(151, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(151, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1441, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1442, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_71_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 71, GeneratedRuleError::Fatal; self.parse_generated_rule_71(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_71(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 142isize, 71, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1446 = false;
                loop {
                    match self.base.sync_decision(atn(), 1446, !__ctx.has_matched_child(), __loop_iter_1446) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 | 176 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1446, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1446 = true;
                            let __invoking_marker = self.base.push_invoking_state(1443isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1452 = false;
                loop {
                    match self.base.sync_decision(atn(), 1452, !__ctx.has_matched_child(), __loop_iter_1452) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        176 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1452, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1452 = true;
                            let __invoking_marker = self.base.push_invoking_state(1449isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1455isize);
                let __child = self.parse_generated_rule_237_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1457, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    54 | 64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1457, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_set_recovering(&[(54, 54), (64, 64)], 1458, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1459isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1461, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1461, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1460isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1464, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1464) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(156, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(156, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1464, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1463isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1467, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1467, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1466isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1472 = false;
                loop {
                    match self.base.sync_decision(atn(), 1472, !__ctx.has_matched_child(), __loop_iter_1472) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1472) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(158, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(158, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1472, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1472 = true;
                            let __invoking_marker = self.base.push_invoking_state(1469isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1483, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1483) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(160, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(160, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1483, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1479, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_1479 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1479, !__ctx.has_matched_child(), __loop_iter_1479) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1479, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1479 = true;
                                    let __invoking_marker = self.base.push_invoking_state(1476isize);
                                    let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(198, 1484, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1486, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1486) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(161, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(161, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1486, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1487, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_72_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 72, GeneratedRuleError::Fatal; self.parse_generated_rule_72(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_72(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 144isize, 72, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1491 = false;
                loop {
                    match self.base.sync_decision(atn(), 1491, !__ctx.has_matched_child(), __loop_iter_1491) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 54 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1491, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1491 = true;
                            let __invoking_marker = self.base.push_invoking_state(1488isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1497 = false;
                loop {
                    match self.base.sync_decision(atn(), 1497, !__ctx.has_matched_child(), __loop_iter_1497) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        54 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1497, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1497 = true;
                            let __invoking_marker = self.base.push_invoking_state(1494isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(54, 1501, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1501isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1503, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1503, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1502isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1506, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1506) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(165, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(165, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1506, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1505isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1509, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1509, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1508isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1514 = false;
                loop {
                    match self.base.sync_decision(atn(), 1514, !__ctx.has_matched_child(), __loop_iter_1514) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1514) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(167, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(167, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1514, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1514 = true;
                            let __invoking_marker = self.base.push_invoking_state(1511isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1525, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1525) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(169, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(169, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1525, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1521, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_1521 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1521, !__ctx.has_matched_child(), __loop_iter_1521) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1521, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1521 = true;
                                    let __invoking_marker = self.base.push_invoking_state(1518isize);
                                    let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(198, 1526, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1528, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1528) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(170, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(170, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1528, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1529, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_73_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 73, GeneratedRuleError::Fatal; self.parse_generated_rule_73(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_73(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 146isize, 73, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1533 = false;
                loop {
                    match self.base.sync_decision(atn(), 1533, !__ctx.has_matched_child(), __loop_iter_1533) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 76 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1533, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1533 = true;
                            let __invoking_marker = self.base.push_invoking_state(1530isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1539 = false;
                loop {
                    match self.base.sync_decision(atn(), 1539, !__ctx.has_matched_child(), __loop_iter_1539) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        76 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1539, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1539 = true;
                            let __invoking_marker = self.base.push_invoking_state(1536isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(76, 1543, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1543isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1545, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1545, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1544isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1548, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1548) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(174, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(174, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1548, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1547isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1551, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1551, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1550isize);
                        let __child = self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1556 = false;
                loop {
                    match self.base.sync_decision(atn(), 1556, !__ctx.has_matched_child(), __loop_iter_1556) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1556) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(176, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(176, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1556, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1556 = true;
                            let __invoking_marker = self.base.push_invoking_state(1553isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1567, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1567) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(178, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(178, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1567, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(197, 1563, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_1563 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1563, !__ctx.has_matched_child(), __loop_iter_1563) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=83 | 85 | 87..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1563, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1563 = true;
                                    let __invoking_marker = self.base.push_invoking_state(1560isize);
                                    let __child = self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(198, 1568, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1570, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1570) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(179, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(179, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1570, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(167, 1571, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_74_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 74, GeneratedRuleError::Fatal; self.parse_generated_rule_74(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_74(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 148isize, 74, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1575 = false;
                loop {
                    match self.base.sync_decision(atn(), 1575, !__ctx.has_matched_child(), __loop_iter_1575) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        13 | 16 | 18 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1575, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1575 = true;
                            let __invoking_marker = self.base.push_invoking_state(1572isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1581 = false;
                loop {
                    match self.base.sync_decision(atn(), 1581, !__ctx.has_matched_child(), __loop_iter_1581) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1581, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1581 = true;
                            let __invoking_marker = self.base.push_invoking_state(1578isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(18, 1585, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1585isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(1586isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1588, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1588, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1587isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1590isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1594 = false;
                loop {
                    match self.base.sync_decision(atn(), 1594, !__ctx.has_matched_child(), __loop_iter_1594) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        78 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1594, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1594 = true;
                            let __invoking_marker = self.base.push_invoking_state(1591isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(167, 1598, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_75_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 75, GeneratedRuleError::Fatal; self.parse_generated_rule_75(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_75(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 150isize, 75, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1602 = false;
                loop {
                    match self.base.sync_decision(atn(), 1602, !__ctx.has_matched_child(), __loop_iter_1602) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1602) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(184, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(184, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1602, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1602 = true;
                            let __invoking_marker = self.base.push_invoking_state(1599isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1608 = false;
                loop {
                    match self.base.sync_decision(atn(), 1608, !__ctx.has_matched_child(), __loop_iter_1608) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1608) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(185, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(185, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1608, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1608 = true;
                            let __invoking_marker = self.base.push_invoking_state(1605isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1611isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_76_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 76, GeneratedRuleError::Fatal; self.parse_generated_rule_76_precedence(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_76(&mut self, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        self.parse_generated_rule_76_precedence(0, allow_fallback)
    }

    #[allow(dead_code)]
    fn parse_generated_rule_76_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! {
            recursive self, 152isize, 76, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    28 | 39 | 43 | 53 | 58 | 70 | 72..=73 | 75 | 82..=83 | 85 | 95 | 100..=101 | 111 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    116 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1620, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1620) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(186, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(186, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1620, &__prediction);
                match __prediction.alt {
                    1 => {
                        let action = self.base.parser_action_at_current_indexed(1613, 76, 1, __rule_start, __consumed_eof);
                        let _ = action;
                        let __invoking_marker = self.base.push_invoking_state(1614isize);
                        let __child = self.parse_generated_rule_79_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1615isize);
                        let __child = self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(1616isize);
                        let __child = self.parse_generated_rule_85_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(1617isize);
                        let __child = self.parse_generated_rule_86_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(1618isize);
                        let __child = self.parse_generated_rule_87_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(1619isize);
                        let __child = self.parse_generated_rule_88_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                loop {
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 1634, __precedence) {
                        Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None },
                        Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        None => {
                            let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize };
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            match __simulator.adaptive_predict_stream_info_with_context(189, __prediction_precedence, self.base.input(), __prediction_context) {
                                Ok(__prediction) => __prediction,
                                Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None },
                                Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1634, &__prediction);
                    match __prediction.alt {
                        1 => {
                            self.base.parse_listener_exit_rule(76);
                            if let Some(__depth_error) = self.base.rule_depth_cap_violation() {
                                return Err(__depth_error);
                            }
                            self.base.push_new_recursion_context_with_previous(152isize, 76, &mut __ctx);
                            if let Some(__listener_error) = self.base.parse_listener_enter_rule(76) {
                                return Err(__listener_error);
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(188, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            match __prediction.alt {
                                1 => {
                                    if !self.base.precpred(9) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 9)"));
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1623isize);
                                    let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                    let mut __loop_iter_1626 = true;
                                    loop {
                                        match self.base.sync_decision(atn(), 1626, !__ctx.has_matched_child(), __loop_iter_1626) {
                                            Ok(__sync_children) => {
                                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                            }
                                            Err(__error) => {
                                                __sync_error = Some(__error.clone());
                                                return Err(__error);
                                            }
                                        }
                                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                        let __prediction = {
                                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                            __simulator.adaptive_predict_stream_info_with_context(187, 0, self.base.input(), __prediction_context)
                                                .map_err(|__error| match __error {
                                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                                })?
                                        };
                                        self.base.record_generated_prediction_diagnostic(atn(), 1626, &__prediction);
                                        match __prediction.alt {
                                            1 => {
                                                __loop_iter_1626 = true;
                                                let __invoking_marker = self.base.push_invoking_state(1623isize);
                                                let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                                self.base.discard_invoking_state(__invoking_marker);
                                                let __child = __child?;
                                                self.base.add_parse_child(&mut __ctx, __child);
                                            }
                                            2 => {
                                                break;
                                            }
                                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                        }
                                    }
                                }
                                2 => {
                                    if !self.base.precpred(6) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 6)"));
                                    }
                                    let __match = self.base.match_token_recovering(171, 1633, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                3 => {
                                    if !self.base.precpred(5) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 5)"));
                                    }
                                    let __match = self.base.match_token_recovering(161, 1633, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => break,
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_77_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 77, GeneratedRuleError::Fatal; self.parse_generated_rule_77(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_77(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 154isize, 77, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(1637isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(1638isize);
                let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1641 = true;
                loop {
                    match self.base.sync_decision(atn(), 1641, !__ctx.has_matched_child(), __loop_iter_1641) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1641) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(190, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(190, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1641, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1641 = true;
                            let __invoking_marker = self.base.push_invoking_state(1638isize);
                            let __child = self.parse_generated_rule_78_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_78_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 78, GeneratedRuleError::Fatal; self.parse_generated_rule_78(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_78(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 156isize, 78, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 1656, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1656, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1656) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(194, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(194, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1656, &__prediction);
                match __prediction.alt {
                    1 => {
                        match self.base.sync_decision(atn(), 1645, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            163 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1645, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1644isize);
                                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1644isize)).map_err(GeneratedRuleError::into_error) };
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let mut __loop_iter_1653 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1653, !__ctx.has_matched_child(), __loop_iter_1653) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1653, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1653 = true;
                                    let __match = self.base.match_token_recovering(163, 1649, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    match self.base.sync_decision(atn(), 1649, !__ctx.has_matched_child(), false) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        Err(__error) => {
                                            __sync_error = Some(__error.clone());
                                            return Err(__error);
                                        }
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = match self.base.la(1) {
                                        3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        163 | 203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    };
                                    self.base.record_generated_prediction_diagnostic(atn(), 1649, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            let __invoking_marker = self.base.push_invoking_state(1648isize);
                                            let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1648isize)).map_err(GeneratedRuleError::into_error) };
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        2 => {
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(203, 1659, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_79_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 79, GeneratedRuleError::Fatal; self.parse_generated_rule_79(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_79(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 158isize, 79, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(18, 1661, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(161, 1663, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1663, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    15 | 32 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1663, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1662isize);
                        let __child = self.parse_generated_rule_80_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1665isize);
                let __child = self.parse_generated_rule_83_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_80_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 80, GeneratedRuleError::Fatal; self.parse_generated_rule_80(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_80(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 160isize, 80, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    32 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1675, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            32 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            15 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1675, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(32, 1669, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 1669, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            168 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1669, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1668isize);
                                let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(15, 1673, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 1673, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            168 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1673, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1672isize);
                                let __child = self.parse_generated_rule_81_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_81_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 81, GeneratedRuleError::Fatal; self.parse_generated_rule_81(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_81(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 162isize, 81, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 1678, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1678isize);
                let __child = self.parse_generated_rule_82_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1683 = false;
                loop {
                    match self.base.sync_decision(atn(), 1683, !__ctx.has_matched_child(), __loop_iter_1683) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1683, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1683 = true;
                            let __match = self.base.match_token_recovering(163, 1680, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(1680isize);
                            let __child = self.parse_generated_rule_82_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(203, 1687, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_82_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 82, GeneratedRuleError::Fatal; self.parse_generated_rule_82(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_82(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 164isize, 82, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(1688isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_83_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 83, GeneratedRuleError::Fatal; self.parse_generated_rule_83(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_83(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 166isize, 83, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(168, 1691, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1691isize);
                let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1696 = false;
                loop {
                    match self.base.sync_decision(atn(), 1696, !__ctx.has_matched_child(), __loop_iter_1696) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        170 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1696, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1696 = true;
                            let __match = self.base.match_token_recovering(163, 1693, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(1693isize);
                            let __child = self.parse_generated_rule_84_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(170, 1700, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_84_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 84, GeneratedRuleError::Fatal; self.parse_generated_rule_84(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_84(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 168isize, 84, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1704 = false;
                loop {
                    match self.base.sync_decision(atn(), 1704, !__ctx.has_matched_child(), __loop_iter_1704) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1704, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1704 = true;
                            let __invoking_marker = self.base.push_invoking_state(1701isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1710 = false;
                loop {
                    match self.base.sync_decision(atn(), 1710, !__ctx.has_matched_child(), __loop_iter_1710) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1710) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(202, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(202, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1710, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1710 = true;
                            let __invoking_marker = self.base.push_invoking_state(1707isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1713isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_85_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 85, GeneratedRuleError::Fatal; self.parse_generated_rule_85(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_85(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 170isize, 85, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_set_recovering(&[(28, 28), (39, 39), (43, 43), (53, 53), (58, 58), (70, 70), (72, 73), (75, 75), (82, 83), (85, 85), (95, 95), (100, 101), (111, 111)], 1716, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_86_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 86, GeneratedRuleError::Fatal; self.parse_generated_rule_86(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_86(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 172isize, 86, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(116, 1719, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1719, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    24 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 37..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1719, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(24, 1720, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1721isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_87_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 87, GeneratedRuleError::Fatal; self.parse_generated_rule_87(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_87(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 174isize, 87, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(48, 1724, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1724isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_88_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 88, GeneratedRuleError::Fatal; self.parse_generated_rule_88(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_88(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 176isize, 88, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 1727, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1727isize);
                let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(163, 1729, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1729isize);
                let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_1732 = true;
                loop {
                    match self.base.sync_decision(atn(), 1732, !__ctx.has_matched_child(), __loop_iter_1732) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1732, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1732 = true;
                            let __match = self.base.match_token_recovering(163, 1729, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(1729isize);
                            let __child = self.parse_generated_rule_89_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(201, 1735, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_89_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 89, GeneratedRuleError::Fatal; self.parse_generated_rule_89(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_89(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 178isize, 89, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(1736isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1738, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1738, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1737isize);
                        let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_90_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 90, GeneratedRuleError::Fatal; self.parse_generated_rule_90(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_90(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 180isize, 90, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    31 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    147 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5..=8 | 29 | 51 | 56 | 67 | 81 | 96 | 98..=99 | 125 | 127 | 130 | 156 | 160..=162 | 164..=165 | 172 | 175 | 178..=186 | 194..=196 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    109 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    148 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    94 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    47 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    55 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    118 => antlr4_runtime::ParserAtnPrediction { alt: 20, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    79 => antlr4_runtime::ParserAtnPrediction { alt: 23, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1764, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1764) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(206, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(206, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1764, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1740isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1741isize);
                        let __child = self.parse_generated_rule_91_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(1742isize);
                        let __child = self.parse_generated_rule_92_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(1743isize);
                        let __child = self.parse_generated_rule_93_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(1744isize);
                        let __child = self.parse_generated_rule_96_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(1745isize);
                        let __child = self.parse_generated_rule_97_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(1746isize);
                        let __child = self.parse_generated_rule_98_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __invoking_marker = self.base.push_invoking_state(1747isize);
                        let __child = self.parse_generated_rule_106_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __invoking_marker = self.base.push_invoking_state(1748isize);
                        let __child = self.parse_generated_rule_99_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    10 => {
                        let __invoking_marker = self.base.push_invoking_state(1749isize);
                        let __child = self.parse_generated_rule_100_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(1750isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(101, 0) } else { self.parse_generated_rule_101_adaptive_dispatch(0, false, Some(1750isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    12 => {
                        let __invoking_marker = self.base.push_invoking_state(1751isize);
                        let __child = self.parse_generated_rule_102_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    13 => {
                        let __invoking_marker = self.base.push_invoking_state(1752isize);
                        let __child = self.parse_generated_rule_103_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    14 => {
                        let __invoking_marker = self.base.push_invoking_state(1753isize);
                        let __child = self.parse_generated_rule_105_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    15 => {
                        let __invoking_marker = self.base.push_invoking_state(1754isize);
                        let __child = self.parse_generated_rule_107_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    16 => {
                        let __invoking_marker = self.base.push_invoking_state(1755isize);
                        let __child = self.parse_generated_rule_108_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    17 => {
                        let __invoking_marker = self.base.push_invoking_state(1756isize);
                        let __child = self.parse_generated_rule_109_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    18 => {
                        let __invoking_marker = self.base.push_invoking_state(1757isize);
                        let __child = self.parse_generated_rule_110_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    19 => {
                        let __invoking_marker = self.base.push_invoking_state(1758isize);
                        let __child = self.parse_generated_rule_138_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    20 => {
                        let __invoking_marker = self.base.push_invoking_state(1759isize);
                        let __child = self.parse_generated_rule_139_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    21 => {
                        let __invoking_marker = self.base.push_invoking_state(1760isize);
                        let __child = self.parse_generated_rule_144_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    22 => {
                        let __invoking_marker = self.base.push_invoking_state(1761isize);
                        let __child = self.parse_generated_rule_145_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    23 => {
                        let __invoking_marker = self.base.push_invoking_state(1762isize);
                        let __child = self.parse_generated_rule_146_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    24 => {
                        let __invoking_marker = self.base.push_invoking_state(1763isize);
                        let __child = self.parse_generated_rule_147_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_91_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 91, GeneratedRuleError::Fatal; self.parse_generated_rule_91(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_91(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 182isize, 91, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1769 = false;
                loop {
                    match self.base.sync_decision(atn(), 1769, !__ctx.has_matched_child(), __loop_iter_1769) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        62 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1769, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1769 = true;
                            let __invoking_marker = self.base.push_invoking_state(1766isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(62, 1774, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1774, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1774, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1773isize);
                        let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 1777, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_92_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 92, GeneratedRuleError::Fatal; self.parse_generated_rule_92(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_92(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 184isize, 92, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1781 = false;
                loop {
                    match self.base.sync_decision(atn(), 1781, !__ctx.has_matched_child(), __loop_iter_1781) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        14 | 27 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1781, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1781 = true;
                            let __invoking_marker = self.base.push_invoking_state(1778isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_set_recovering(&[(14, 14), (27, 27)], 1785, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1785isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_93_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 93, GeneratedRuleError::Fatal; self.parse_generated_rule_93(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_93(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 186isize, 93, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 1789, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1789) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(210, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(210, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1789, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1787isize);
                        let __child = self.parse_generated_rule_94_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(1788isize);
                        let __child = self.parse_generated_rule_95_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_94_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 94, GeneratedRuleError::Fatal; self.parse_generated_rule_94(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_94(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 188isize, 94, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1794 = false;
                loop {
                    match self.base.sync_decision(atn(), 1794, !__ctx.has_matched_child(), __loop_iter_1794) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        31 | 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1794, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1794 = true;
                            let __invoking_marker = self.base.push_invoking_state(1791isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1798, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1798, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(61, 1799, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(31, 1801, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1802, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1802isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(1803isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(149, 1805, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1805isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1805isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 1807, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1807isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_95_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 95, GeneratedRuleError::Fatal; self.parse_generated_rule_95(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_95(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 190isize, 95, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1812 = false;
                loop {
                    match self.base.sync_decision(atn(), 1812, !__ctx.has_matched_child(), __loop_iter_1812) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        31 | 61 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1812, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1812 = true;
                            let __invoking_marker = self.base.push_invoking_state(1809isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1816, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    31 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1816, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(61, 1817, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(31, 1819, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1820, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1820isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1820isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(149, 1822, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1822isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1822isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 1824, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1824isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_96_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 96, GeneratedRuleError::Fatal; self.parse_generated_rule_96(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_96(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 192isize, 96, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1829 = false;
                loop {
                    match self.base.sync_decision(atn(), 1829, !__ctx.has_matched_child(), __loop_iter_1829) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        17 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1829, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1829 = true;
                            let __invoking_marker = self.base.push_invoking_state(1826isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(17, 1834, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1834, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1834, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1833isize);
                        let __child = self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 1837, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_97_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 97, GeneratedRuleError::Fatal; self.parse_generated_rule_97(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_97(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 194isize, 97, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1841 = false;
                loop {
                    match self.base.sync_decision(atn(), 1841, !__ctx.has_matched_child(), __loop_iter_1841) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        147 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1841, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1841 = true;
                            let __invoking_marker = self.base.push_invoking_state(1838isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(147, 1845, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1845isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(79, 1847, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1848, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1848isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1848isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 1850, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(167, 1851, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 98, GeneratedRuleError::Fatal; self.parse_generated_rule_98(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 196isize, 98, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1855 = false;
                loop {
                    match self.base.sync_decision(atn(), 1855, !__ctx.has_matched_child(), __loop_iter_1855) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1855, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1855 = true;
                            let __invoking_marker = self.base.push_invoking_state(1852isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(167, 1859, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_99_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 99, GeneratedRuleError::Fatal; self.parse_generated_rule_99(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_99(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 198isize, 99, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1863 = false;
                loop {
                    match self.base.sync_decision(atn(), 1863, !__ctx.has_matched_child(), __loop_iter_1863) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1863) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(219, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(219, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1863, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1863 = true;
                            let __invoking_marker = self.base.push_invoking_state(1860isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1866isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1866isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 1868, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_100_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 100, GeneratedRuleError::Fatal; self.parse_generated_rule_100(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_100(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 200isize, 100, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1872 = false;
                loop {
                    match self.base.sync_decision(atn(), 1872, !__ctx.has_matched_child(), __loop_iter_1872) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        69 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1872, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1872 = true;
                            let __invoking_marker = self.base.push_invoking_state(1869isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(69, 1876, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1877, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1877isize);
                let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 1879, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1879isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_101_adaptive_dispatch(&mut self, precedence: i32, allow_fallback: bool, invoking_state: Option<isize>) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        if self.generated_only() || self.base.has_rule_depth_cap() || self.base.has_parse_listeners() || self.base.observes_parser_decisions() {
            return self.parse_generated_rule_101_dispatch(precedence, allow_fallback);
        }
        let __adaptive_outermost = self.adaptive_atn_preference_depths[0] == 0;
        let __adaptive_rule_start = antlr4_runtime::IntStream::index(self.base.input());
        let __adaptive_parser_state = self.base.state();
        let __adaptive_diagnostic_marker = self.base.generated_diagnostics_checkpoint();
        if __adaptive_outermost {
            self.adaptive_atn_preference_starts[0] = self.simulator
                .as_ref()
                .and_then(antlr4_runtime::ParserAtnSimulator::adaptive_prediction_work)
                .unwrap_or((0, 0));
        self.adaptive_atn_syntax_error_starts[0] = self.base.number_of_syntax_errors();
        }
        self.adaptive_atn_preference_depths[0] += 1;
        let mut __result = self.parse_generated_rule_101_dispatch(precedence, allow_fallback);
        self.adaptive_atn_preference_depths[0] -= 1;
        if !self.adaptive_atn_preferred_rules[0] {
            if let Some(__adaptive_after) = self.simulator
                .as_ref()
                .and_then(antlr4_runtime::ParserAtnSimulator::adaptive_prediction_work)
            {
                let __adaptive_expensive = __result.is_ok()
                        && self.base.number_of_syntax_errors() == self.adaptive_atn_syntax_error_starts[0]
                        && antlr4_runtime::ParserAtnSimulator::adaptive_prediction_delta_is_expensive(self.adaptive_atn_preference_starts[0], __adaptive_after);
                self.adaptive_atn_preferred_rules[0] = __adaptive_expensive;
                if __adaptive_expensive {
                    self.adaptive_atn_retry_slot = Some(0);
                    __result = Err(GeneratedRuleError::AdaptiveRetry);
                }
            }
        }
        if __adaptive_outermost
            && self.adaptive_atn_retry_slot == Some(0)
            && matches!(&__result, Err(GeneratedRuleError::AdaptiveRetry))
        {
            self.adaptive_atn_retry_slot = None;
            self.base.restore_generated_diagnostics(__adaptive_diagnostic_marker);
            antlr4_runtime::IntStream::seek(self.base.input(), __adaptive_rule_start);
            self.base.set_state(__adaptive_parser_state);
            if let Some(invoking_state) = invoking_state {
                self.base.push_invoking_state(invoking_state);
            }
            return self.parse_rule_precedence_from_generated(101, precedence).map_err(GeneratedRuleError::Interpreted);
        }
        __result
    }

    #[allow(dead_code)]
    fn parse_generated_rule_101_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 101, GeneratedRuleError::Fatal; self.parse_generated_rule_101(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_101(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 202isize, 101, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1884 = false;
                loop {
                    match self.base.sync_decision(atn(), 1884, !__ctx.has_matched_child(), __loop_iter_1884) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        109 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1884, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1884 = true;
                            let __invoking_marker = self.base.push_invoking_state(1881isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(109, 1888, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1902, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1902, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1902) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(225, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(225, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1902, &__prediction);
                match __prediction.alt {
                    1 => {
                        match self.base.sync_decision(atn(), 1890, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            4 | 9..=10 | 15 | 18 | 25 | 28 | 32..=34 | 37..=40 | 42..=43 | 46 | 48 | 50 | 53 | 58..=61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=112 | 114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1890, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1889isize);
                                let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        match self.base.sync_decision(atn(), 1900, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1900, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(1892isize);
                                let __child = self.parse_generated_rule_148_adaptive_probe_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                                let mut __loop_iter_1897 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 1897, !__ctx.has_matched_child(), __loop_iter_1897) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        Err(__error) => {
                                            __sync_error = Some(__error.clone());
                                            return Err(__error);
                                        }
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = match self.base.la(1) {
                                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    };
                                    self.base.record_generated_prediction_diagnostic(atn(), 1897, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1897 = true;
                                            let __match = self.base.match_token_recovering(163, 1894, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                            let __invoking_marker = self.base.push_invoking_state(1894isize);
                                            let __child = self.parse_generated_rule_148_adaptive_probe_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        2 => {
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 1906, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1906, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1906, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1905isize);
                        let __child = self.parse_generated_rule_148_adaptive_probe_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 1917, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1917, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1917, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1909isize);
                        let __child = self.parse_generated_rule_148_adaptive_probe_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_1914 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1914, !__ctx.has_matched_child(), __loop_iter_1914) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1914, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1914 = true;
                                    let __match = self.base.match_token_recovering(163, 1911, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(1911isize);
                                    let __child = self.parse_generated_rule_148_adaptive_probe_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 1920, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1920isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_102_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 102, GeneratedRuleError::Fatal; self.parse_generated_rule_102(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_102(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 204isize, 102, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1925 = false;
                loop {
                    match self.base.sync_decision(atn(), 1925, !__ctx.has_matched_child(), __loop_iter_1925) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        90 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1925, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1925 = true;
                            let __invoking_marker = self.base.push_invoking_state(1922isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(90, 1930, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 1930, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1930) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(230, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(230, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1930, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_set_recovering(&[(29, 29), (84, 84)], 1931, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1933, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1933, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1932isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1932isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 1936, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_103_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 103, GeneratedRuleError::Fatal; self.parse_generated_rule_103(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_103(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 206isize, 103, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1940 = false;
                loop {
                    match self.base.sync_decision(atn(), 1940, !__ctx.has_matched_child(), __loop_iter_1940) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        148 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1940, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1940 = true;
                            let __invoking_marker = self.base.push_invoking_state(1937isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(148, 1944, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 1945, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1945isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(1945isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 1947, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1947isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 1949, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1949) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(233, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(233, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1949, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1948isize);
                        let __child = self.parse_generated_rule_104_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_104_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 104, GeneratedRuleError::Fatal; self.parse_generated_rule_104(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_104(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 208isize, 104, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(86, 1952, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1952isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_105_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 105, GeneratedRuleError::Fatal; self.parse_generated_rule_105(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_105(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 210isize, 105, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1957 = false;
                loop {
                    match self.base.sync_decision(atn(), 1957, !__ctx.has_matched_child(), __loop_iter_1957) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1957, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1957 = true;
                            let __invoking_marker = self.base.push_invoking_state(1954isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1960isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 1962, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(1962isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_106_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 106, GeneratedRuleError::Fatal; self.parse_generated_rule_106(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_106(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 212isize, 106, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1967 = false;
                loop {
                    match self.base.sync_decision(atn(), 1967, !__ctx.has_matched_child(), __loop_iter_1967) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1967, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1967 = true;
                            let __invoking_marker = self.base.push_invoking_state(1964isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 1971, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1971) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(236, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(236, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1971, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(61, 1972, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 1974, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    77 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1974, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(77, 1975, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1979 = false;
                loop {
                    match self.base.sync_decision(atn(), 1979, !__ctx.has_matched_child(), __loop_iter_1979) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1979) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(238, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(238, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1979, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1979 = true;
                            let __invoking_marker = self.base.push_invoking_state(1976isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1982isize);
                let __child = self.parse_generated_rule_242_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(167, 1984, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_107_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 107, GeneratedRuleError::Fatal; self.parse_generated_rule_107(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_107(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 214isize, 107, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_1988 = false;
                loop {
                    match self.base.sync_decision(atn(), 1988, !__ctx.has_matched_child(), __loop_iter_1988) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1988, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1988 = true;
                            let __invoking_marker = self.base.push_invoking_state(1985isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_1994 = false;
                loop {
                    match self.base.sync_decision(atn(), 1994, !__ctx.has_matched_child(), __loop_iter_1994) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1994) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(240, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(240, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1994, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1994 = true;
                            let __invoking_marker = self.base.push_invoking_state(1991isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1997isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(1998isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2000, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2000, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(1999isize);
                        let __child = self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2002isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2006 = false;
                loop {
                    match self.base.sync_decision(atn(), 2006, !__ctx.has_matched_child(), __loop_iter_2006) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        78 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        138 | 197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2006, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2006 = true;
                            let __invoking_marker = self.base.push_invoking_state(2003isize);
                            let __child = self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2013, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2013, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2009isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2010isize);
                        let __child = self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(167, 2012, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_108_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 108, GeneratedRuleError::Fatal; self.parse_generated_rule_108(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_108(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 216isize, 108, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2018 = false;
                loop {
                    match self.base.sync_decision(atn(), 2018, !__ctx.has_matched_child(), __loop_iter_2018) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        94 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2018, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2018 = true;
                            let __invoking_marker = self.base.push_invoking_state(2015isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(94, 2022, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2023, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2023isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2023isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2025, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2025isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_109_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 109, GeneratedRuleError::Fatal; self.parse_generated_rule_109(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_109(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 218isize, 109, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2030 = false;
                loop {
                    match self.base.sync_decision(atn(), 2030, !__ctx.has_matched_child(), __loop_iter_2030) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2030, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2030 = true;
                            let __invoking_marker = self.base.push_invoking_state(2027isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(47, 2035, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2035, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2035, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2034isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2034isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 2038, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_110_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 110, GeneratedRuleError::Fatal; self.parse_generated_rule_110(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_110(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 220isize, 110, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2042 = false;
                loop {
                    match self.base.sync_decision(atn(), 2042, !__ctx.has_matched_child(), __loop_iter_2042) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        55 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2042, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2042 = true;
                            let __invoking_marker = self.base.push_invoking_state(2039isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(55, 2046, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2047, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2047isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2047isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2049, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(197, 2053, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_2053 = false;
                loop {
                    match self.base.sync_decision(atn(), 2053, !__ctx.has_matched_child(), __loop_iter_2053) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        29 | 84 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2053, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2053 = true;
                            let __invoking_marker = self.base.push_invoking_state(2050isize);
                            let __child = self.parse_generated_rule_111_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(198, 2057, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_111_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 111, GeneratedRuleError::Fatal; self.parse_generated_rule_111(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_111(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 222isize, 111, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2058isize);
                let __child = self.parse_generated_rule_112_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2061 = true;
                loop {
                    match self.base.sync_decision(atn(), 2061, !__ctx.has_matched_child(), __loop_iter_2061) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2061) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(249, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(249, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2061, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2061 = true;
                            let __invoking_marker = self.base.push_invoking_state(2058isize);
                            let __child = self.parse_generated_rule_112_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(2063isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2066 = true;
                loop {
                    match self.base.sync_decision(atn(), 2066, !__ctx.has_matched_child(), __loop_iter_2066) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2066) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(250, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(250, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2066, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2066 = true;
                            let __invoking_marker = self.base.push_invoking_state(2063isize);
                            let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_112_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 112, GeneratedRuleError::Fatal; self.parse_generated_rule_112(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_112(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 224isize, 112, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2071, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2071) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(251, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(251, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2071, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2068isize);
                        let __child = self.parse_generated_rule_113_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2069isize);
                        let __child = self.parse_generated_rule_136_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2070isize);
                        let __child = self.parse_generated_rule_137_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_113_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 113, GeneratedRuleError::Fatal; self.parse_generated_rule_113(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_113(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 226isize, 113, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(84, 2074, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2074isize);
                let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2076, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    102 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2076, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2075isize);
                        let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(199, 2079, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_114_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 114, GeneratedRuleError::Fatal; self.parse_generated_rule_114_precedence(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_114(&mut self, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        self.parse_generated_rule_114_precedence(0, allow_fallback)
    }

    #[allow(dead_code)]
    fn parse_generated_rule_114_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! {
            recursive self, 228isize, 114, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 2092, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2092) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(253, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(253, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2092, &__prediction);
                match __prediction.alt {
                    1 => {
                        let action = self.base.parser_action_at_current_indexed(2080, 114, 2, __rule_start, __consumed_eof);
                        let _ = action;
                        let __invoking_marker = self.base.push_invoking_state(2081isize);
                        let __child = self.parse_generated_rule_134_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2082isize);
                        let __child = self.parse_generated_rule_115_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2083isize);
                        let __child = self.parse_generated_rule_116_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(2084isize);
                        let __child = self.parse_generated_rule_121_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(2085isize);
                        let __child = self.parse_generated_rule_122_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(2086isize);
                        let __child = self.parse_generated_rule_123_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(2087isize);
                        let __child = self.parse_generated_rule_124_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __invoking_marker = self.base.push_invoking_state(2088isize);
                        let __child = self.parse_generated_rule_130_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __invoking_marker = self.base.push_invoking_state(2089isize);
                        let __child = self.parse_generated_rule_131_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    10 => {
                        let __invoking_marker = self.base.push_invoking_state(2090isize);
                        let __child = self.parse_generated_rule_132_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(2091isize);
                        let __child = self.parse_generated_rule_133_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                loop {
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 2099, __precedence) {
                        Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None },
                        Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        None => {
                            let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize };
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            match __simulator.adaptive_predict_stream_info_with_context(254, __prediction_precedence, self.base.input(), __prediction_context) {
                                Ok(__prediction) => __prediction,
                                Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None },
                                Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    };
                    let __prediction = if __prediction.alt == 1 {
                        let __semantic_la = self.base.la(1);
                        if __semantic_la == 108 || __semantic_la == 152 {
                            __prediction
                        } else {
                            antlr4_runtime::ParserAtnPrediction { alt: 2, ..__prediction }
                        }
                    } else {
                        __prediction
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2099, &__prediction);
                    match __prediction.alt {
                        1 => {
                            self.base.parse_listener_exit_rule(114);
                            if let Some(__depth_error) = self.base.rule_depth_cap_violation() {
                                return Err(__depth_error);
                            }
                            self.base.push_new_recursion_context_with_previous(228isize, 114, &mut __ctx);
                            if let Some(__listener_error) = self.base.parse_listener_enter_rule(114) {
                                return Err(__listener_error);
                            }
                            if !self.base.precpred(12) {
                                return Err(self.base.failed_predicate_error("precpred(_ctx, 12)"));
                            }
                            let __match = self.base.match_set_recovering(&[(108, 108), (152, 152)], 2096, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(2096isize);
                            let __child = self.parse_generated_rule_114_dispatch(13, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => break,
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_115_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 115, GeneratedRuleError::Fatal; self.parse_generated_rule_115(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_115(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 230isize, 115, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2102isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2102isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_116_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 116, GeneratedRuleError::Fatal; self.parse_generated_rule_116(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_116(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 232isize, 116, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2104isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(2105isize);
                let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_117_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 117, GeneratedRuleError::Fatal; self.parse_generated_rule_117(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_117(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 234isize, 117, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107 | 110 | 112 | 117 | 119 | 141 | 146 | 151 | 153 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2110, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2110) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(255, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(255, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2110, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2107isize);
                        let __child = self.parse_generated_rule_118_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2108isize);
                        let __child = self.parse_generated_rule_119_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2109isize);
                        let __child = self.parse_generated_rule_120_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_118_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 118, GeneratedRuleError::Fatal; self.parse_generated_rule_118(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_118(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 236isize, 118, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(173, 2113, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_119_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 119, GeneratedRuleError::Fatal; self.parse_generated_rule_119(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_119(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 238isize, 119, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2123, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2123, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107 | 110 | 112 | 117 | 119 | 141 | 146 | 151 | 153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2123, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2115isize);
                        let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2120 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2120, !__ctx.has_matched_child(), __loop_iter_2120) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2120, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2120 = true;
                                    let __match = self.base.match_token_recovering(163, 2117, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2117isize);
                                    let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 2126, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_120_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 120, GeneratedRuleError::Fatal; self.parse_generated_rule_120(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_120(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 240isize, 120, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_set_recovering(atn().token_set(11).expect("generated parser token-set index"), 2128, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_121_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 121, GeneratedRuleError::Fatal; self.parse_generated_rule_121(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_121(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 242isize, 121, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(173, 2130, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_122_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 122, GeneratedRuleError::Fatal; self.parse_generated_rule_122(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_122(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 244isize, 122, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 2143, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2143, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2143) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(260, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(260, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2143, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2132isize);
                        let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2137 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2137, !__ctx.has_matched_child(), __loop_iter_2137) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2137) {
                                __prediction
                            } else {
                                let __prediction = {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    __simulator.adaptive_predict_stream_info_sll_probe(258, 0, self.base.input())
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                };
                                if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                    __simulator.adaptive_predict_stream_info_with_context(258, 0, self.base.input(), __prediction_context)
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                } else {
                                    __prediction
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2137, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2137 = true;
                                    let __match = self.base.match_token_recovering(163, 2134, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2134isize);
                                    let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 2141, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2141, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(163, 2142, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(203, 2147, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2147, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2147) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(261, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(261, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2147, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2146isize);
                        let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_123_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 123, GeneratedRuleError::Fatal; self.parse_generated_rule_123(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_123(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 246isize, 123, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2150, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2150isize);
                let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2152, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_124_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 124, GeneratedRuleError::Fatal; self.parse_generated_rule_124(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_124(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 248isize, 124, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 2154, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2154) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(262, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(262, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2154, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2153isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2157, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2157) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(263, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(263, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2157, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2156isize);
                        let __child = self.parse_generated_rule_125_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2160, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2160) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(264, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(264, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2160, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2159isize);
                        let __child = self.parse_generated_rule_129_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2163, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2163) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(265, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(265, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2163, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2162isize);
                        let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_125_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 125, GeneratedRuleError::Fatal; self.parse_generated_rule_125(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_125(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 250isize, 125, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2174, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2174, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2174) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(267, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(267, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2174, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2166isize);
                        let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2171 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2171, !__ctx.has_matched_child(), __loop_iter_2171) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2171, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2171 = true;
                                    let __match = self.base.match_token_recovering(163, 2168, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2168isize);
                                    let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 2177, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_126_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 126, GeneratedRuleError::Fatal; self.parse_generated_rule_126(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_126(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 252isize, 126, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 2179, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2179) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(268, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(268, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2179, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2178isize);
                        let __child = self.parse_generated_rule_127_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2181isize);
                let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_127_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 127, GeneratedRuleError::Fatal; self.parse_generated_rule_127(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_127(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 254isize, 127, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5..=8 | 13..=14 | 16 | 18 | 21 | 23..=24 | 26..=29 | 35..=36 | 39 | 41 | 43 | 45 | 49 | 51..=53 | 56..=58 | 65 | 67 | 69..=70 | 72..=75 | 81..=83 | 85 | 95..=96 | 98..=101 | 111 | 113 | 116 | 125 | 127 | 130 | 156 | 160..=162 | 164..=165 | 172 | 175 | 178..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2185, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2185) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(269, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(269, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2185, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2183isize);
                        let __child = self.parse_generated_rule_128_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2184isize);
                        let __child = self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_128_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 128, GeneratedRuleError::Fatal; self.parse_generated_rule_128(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_128(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 256isize, 128, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2187isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2187isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 2189, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_129_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 129, GeneratedRuleError::Fatal; self.parse_generated_rule_129(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_129(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 258isize, 129, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(197, 2202, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2202, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2202) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(272, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(272, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2202, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2191isize);
                        let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2196 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2196, !__ctx.has_matched_child(), __loop_iter_2196) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2196) {
                                __prediction
                            } else {
                                let __prediction = {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    __simulator.adaptive_predict_stream_info_sll_probe(270, 0, self.base.input())
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                };
                                if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                    __simulator.adaptive_predict_stream_info_with_context(270, 0, self.base.input(), __prediction_context)
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                } else {
                                    __prediction
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2196, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2196 = true;
                                    let __match = self.base.match_token_recovering(163, 2193, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2193isize);
                                    let __child = self.parse_generated_rule_126_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 2200, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2200, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(163, 2201, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(198, 2205, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_130_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 130, GeneratedRuleError::Fatal; self.parse_generated_rule_130(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_130(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 260isize, 130, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    120 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    136 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    137 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    170 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    139 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2218, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            120 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            168 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            136 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            137 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            170 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            139 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2218, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(120, 2207, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2207isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2207isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(168, 2209, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2209isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2209isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(136, 2211, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2211isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2211isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(137, 2213, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2213isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2213isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(170, 2215, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2215isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2215isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __match = self.base.match_token_recovering(139, 2217, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2217isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2217isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_131_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 131, GeneratedRuleError::Fatal; self.parse_generated_rule_131(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_131(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 262isize, 131, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(130, 2222, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2222, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2222) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(274, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(274, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2222, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2221isize);
                        let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_132_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 132, GeneratedRuleError::Fatal; self.parse_generated_rule_132(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_132(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 264isize, 132, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2224isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_133_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 133, GeneratedRuleError::Fatal; self.parse_generated_rule_133(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_133(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 266isize, 133, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(114, 2227, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2227isize);
                let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_134_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 134, GeneratedRuleError::Fatal; self.parse_generated_rule_134(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_134(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 268isize, 134, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(119, 2230, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2230isize);
                let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_135_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 135, GeneratedRuleError::Fatal; self.parse_generated_rule_135(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_135(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 270isize, 135, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(102, 2233, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2233isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2233isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_136_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 136, GeneratedRuleError::Fatal; self.parse_generated_rule_136(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_136(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 272isize, 136, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(84, 2236, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2236isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2236isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(199, 2238, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_137_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 137, GeneratedRuleError::Fatal; self.parse_generated_rule_137(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_137(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 274isize, 137, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(29, 2240, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(199, 2241, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_138_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 138, GeneratedRuleError::Fatal; self.parse_generated_rule_138(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_138(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 276isize, 138, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2245 = false;
                loop {
                    match self.base.sync_decision(atn(), 2245, !__ctx.has_matched_child(), __loop_iter_2245) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        74 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2245, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2245 = true;
                            let __invoking_marker = self.base.push_invoking_state(2242isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(74, 2250, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2250, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2250, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2249isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2249isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 2253, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_139_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 139, GeneratedRuleError::Fatal; self.parse_generated_rule_139(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_139(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 278isize, 139, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2257 = false;
                loop {
                    match self.base.sync_decision(atn(), 2257, !__ctx.has_matched_child(), __loop_iter_2257) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        118 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2257, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2257 = true;
                            let __invoking_marker = self.base.push_invoking_state(2254isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(118, 2261, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2261isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2265 = false;
                loop {
                    match self.base.sync_decision(atn(), 2265, !__ctx.has_matched_child(), __loop_iter_2265) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 3..=21 | 23..=43 | 45..=62 | 64..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2265, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2265 = true;
                            let __invoking_marker = self.base.push_invoking_state(2262isize);
                            let __child = self.parse_generated_rule_140_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 2269, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    30 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 3..=21 | 23..=29 | 31..=43 | 45..=62 | 64..=103 | 107..=114 | 116..=119 | 125 | 127 | 130 | 141 | 146..=148 | 151..=153 | 156 | 160..=162 | 164..=165 | 167 | 172..=173 | 175..=186 | 194..=198 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2269, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2268isize);
                        let __child = self.parse_generated_rule_143_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_140_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 140, GeneratedRuleError::Fatal; self.parse_generated_rule_140(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_140(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 280isize, 140, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(63, 2273, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2273, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    102 | 197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2273, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2272isize);
                        let __child = self.parse_generated_rule_141_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2276, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    102 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2276, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2275isize);
                        let __child = self.parse_generated_rule_142_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2278isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_141_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 141, GeneratedRuleError::Fatal; self.parse_generated_rule_141(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_141(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 282isize, 141, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2281, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2281isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2283, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 25 | 32..=34 | 37..=38 | 40 | 42 | 46 | 48 | 50 | 59..=61 | 68 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2283, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2282isize);
                        let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 2286, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_142_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 142, GeneratedRuleError::Fatal; self.parse_generated_rule_142(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_142(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 284isize, 142, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(102, 2288, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2289, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2289isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2289isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2291, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_143_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 143, GeneratedRuleError::Fatal; self.parse_generated_rule_143(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_143(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 286isize, 143, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(30, 2293, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2293isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_144_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 144, GeneratedRuleError::Fatal; self.parse_generated_rule_144(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_144(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 288isize, 144, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2298 = false;
                loop {
                    match self.base.sync_decision(atn(), 2298, !__ctx.has_matched_child(), __loop_iter_2298) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2298, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2298 = true;
                            let __invoking_marker = self.base.push_invoking_state(2295isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(57, 2302, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2302isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_145_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 145, GeneratedRuleError::Fatal; self.parse_generated_rule_145(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_145(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 290isize, 145, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2307 = false;
                loop {
                    match self.base.sync_decision(atn(), 2307, !__ctx.has_matched_child(), __loop_iter_2307) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        61 | 77 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2307, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2307 = true;
                            let __invoking_marker = self.base.push_invoking_state(2304isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 2311, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    77 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2311, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(61, 2312, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(77, 2314, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2317, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5..=8 | 13..=14 | 16 | 21 | 23..=24 | 26..=27 | 29 | 35..=36 | 41 | 45 | 49 | 51..=52 | 56..=57 | 65 | 67 | 69 | 74 | 81 | 96 | 98..=99 | 113 | 125 | 127 | 130 | 156 | 160..=162 | 164..=165 | 172 | 175 | 178..=186 | 194..=197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2317, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2317) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(286, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(286, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2317, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2315isize);
                        let __child = self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2316isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2316isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(201, 2320, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2320isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_146_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 146, GeneratedRuleError::Fatal; self.parse_generated_rule_146(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_146(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 292isize, 146, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2325 = false;
                loop {
                    match self.base.sync_decision(atn(), 2325, !__ctx.has_matched_child(), __loop_iter_2325) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        79 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2325, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2325 = true;
                            let __invoking_marker = self.base.push_invoking_state(2322isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(79, 2329, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2330, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2330isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2330isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2332, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2332isize);
                let __child = self.parse_generated_rule_90_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_147_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 147, GeneratedRuleError::Fatal; self.parse_generated_rule_147(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_147(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 294isize, 147, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2337 = false;
                loop {
                    match self.base.sync_decision(atn(), 2337, !__ctx.has_matched_child(), __loop_iter_2337) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        80 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2337, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2337 = true;
                            let __invoking_marker = self.base.push_invoking_state(2334isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(80, 2341, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_set_recovering(&[(47, 47), (62, 62)], 2343, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2343, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2343, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2342isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2342isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(167, 2346, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_148_adaptive_probe_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let __result = self.parse_generated_rule_148_dispatch(precedence, allow_fallback);
        if __result.is_ok() && self.adaptive_atn_retry_slot.is_none() {
            if let Some(__adaptive_after) = self.simulator
                .as_ref()
                .and_then(antlr4_runtime::ParserAtnSimulator::adaptive_prediction_work)
            {
                if self.adaptive_atn_preference_depths[0] != 0
                    && !self.adaptive_atn_preferred_rules[0]
                    && self.base.number_of_syntax_errors() == self.adaptive_atn_syntax_error_starts[0]
                    && antlr4_runtime::ParserAtnSimulator::adaptive_prediction_delta_is_decisive(self.adaptive_atn_preference_starts[0], __adaptive_after)
                {
                    self.adaptive_atn_preferred_rules[0] = true;
                    self.adaptive_atn_retry_slot = Some(0);
                    return Err(GeneratedRuleError::AdaptiveRetry);
                }
            }
        }
        __result
    }

    #[allow(dead_code)]
    fn parse_generated_rule_148_adaptive_dispatch(&mut self, precedence: i32, allow_fallback: bool, invoking_state: Option<isize>) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        if self.generated_only() || self.base.has_rule_depth_cap() || self.base.has_parse_listeners() || self.base.observes_parser_decisions() {
            return self.parse_generated_rule_148_dispatch(precedence, allow_fallback);
        }
        let __adaptive_outermost = self.adaptive_atn_preference_depths[1] == 0;
        let __adaptive_rule_start = antlr4_runtime::IntStream::index(self.base.input());
        let __adaptive_parser_state = self.base.state();
        let __adaptive_diagnostic_marker = self.base.generated_diagnostics_checkpoint();
        if __adaptive_outermost {
            self.adaptive_atn_preference_starts[1] = self.simulator
                .as_ref()
                .and_then(antlr4_runtime::ParserAtnSimulator::adaptive_prediction_work)
                .unwrap_or((0, 0));
        self.adaptive_atn_syntax_error_starts[1] = self.base.number_of_syntax_errors();
        }
        self.adaptive_atn_preference_depths[1] += 1;
        let mut __result = self.parse_generated_rule_148_dispatch(precedence, allow_fallback);
        self.adaptive_atn_preference_depths[1] -= 1;
        if !self.adaptive_atn_preferred_rules[1] {
            if let Some(__adaptive_after) = self.simulator
                .as_ref()
                .and_then(antlr4_runtime::ParserAtnSimulator::adaptive_prediction_work)
            {
                let __adaptive_expensive = __result.is_ok()
                        && self.base.number_of_syntax_errors() == self.adaptive_atn_syntax_error_starts[1]
                        && antlr4_runtime::ParserAtnSimulator::adaptive_prediction_delta_is_expensive(self.adaptive_atn_preference_starts[1], __adaptive_after);
                self.adaptive_atn_preferred_rules[1] = __adaptive_expensive;
                if __adaptive_expensive {
                    self.adaptive_atn_retry_slot = Some(1);
                    __result = Err(GeneratedRuleError::AdaptiveRetry);
                }
            }
        }
        if __adaptive_outermost
            && self.adaptive_atn_retry_slot == Some(1)
            && matches!(&__result, Err(GeneratedRuleError::AdaptiveRetry))
        {
            self.adaptive_atn_retry_slot = None;
            self.base.restore_generated_diagnostics(__adaptive_diagnostic_marker);
            antlr4_runtime::IntStream::seek(self.base.input(), __adaptive_rule_start);
            self.base.set_state(__adaptive_parser_state);
            if let Some(invoking_state) = invoking_state {
                self.base.push_invoking_state(invoking_state);
            }
            return self.parse_rule_precedence_from_generated(148, precedence).map_err(GeneratedRuleError::Interpreted);
        }
        __result
    }

    #[allow(dead_code)]
    fn parse_generated_rule_148_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 148, GeneratedRuleError::Fatal; self.parse_generated_rule_148_precedence(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_148(&mut self, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        self.parse_generated_rule_148_precedence(0, allow_fallback)
    }

    #[allow(dead_code)]
    fn parse_generated_rule_148_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! {
            recursive self, 296isize, 148, __precedence, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    13 | 16 | 21 | 23..=24 | 26 | 35..=36 | 41 | 45 | 49 | 52 | 65 | 69 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    14 | 27 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    197 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 | 98 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    194..=196 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    6 | 67 | 96 | 99 | 178..=186 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    7 => antlr4_runtime::ParserAtnPrediction { alt: 19, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    165 => antlr4_runtime::ParserAtnPrediction { alt: 20, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    125 | 127 | 156 | 160..=162 | 164 | 172 | 175 => antlr4_runtime::ParserAtnPrediction { alt: 22, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    130 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    8 => antlr4_runtime::ParserAtnPrediction { alt: 26, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 => antlr4_runtime::ParserAtnPrediction { alt: 27, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    51 => antlr4_runtime::ParserAtnPrediction { alt: 28, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    74 => antlr4_runtime::ParserAtnPrediction { alt: 30, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    56 => antlr4_runtime::ParserAtnPrediction { alt: 33, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2386, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2386) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(291, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(291, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2386, &__prediction);
                match __prediction.alt {
                    1 => {
                        let action = self.base.parser_action_at_current_indexed(2347, 148, 3, __rule_start, __consumed_eof);
                        let _ = action;
                        let __invoking_marker = self.base.push_invoking_state(2348isize);
                        let __child = self.parse_generated_rule_149_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2349isize);
                        let __child = self.parse_generated_rule_154_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2350isize);
                        let __child = self.parse_generated_rule_156_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(2351isize);
                        let __child = self.parse_generated_rule_158_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(2352isize);
                        let __child = self.parse_generated_rule_159_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(2353isize);
                        let __child = self.parse_generated_rule_162_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(2354isize);
                        let __child = self.parse_generated_rule_163_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __invoking_marker = self.base.push_invoking_state(2355isize);
                        let __child = self.parse_generated_rule_164_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __invoking_marker = self.base.push_invoking_state(2356isize);
                        let __child = self.parse_generated_rule_170_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    10 => {
                        let __invoking_marker = self.base.push_invoking_state(2357isize);
                        let __child = self.parse_generated_rule_171_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(2358isize);
                        let __child = self.parse_generated_rule_172_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    12 => {
                        let __invoking_marker = self.base.push_invoking_state(2359isize);
                        let __child = self.parse_generated_rule_173_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    13 => {
                        let __invoking_marker = self.base.push_invoking_state(2360isize);
                        let __child = self.parse_generated_rule_174_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    14 => {
                        let __invoking_marker = self.base.push_invoking_state(2361isize);
                        let __child = self.parse_generated_rule_175_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    15 => {
                        let __invoking_marker = self.base.push_invoking_state(2362isize);
                        let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    16 => {
                        let __invoking_marker = self.base.push_invoking_state(2363isize);
                        let __child = self.parse_generated_rule_176_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    17 => {
                        let __invoking_marker = self.base.push_invoking_state(2364isize);
                        let __child = self.parse_generated_rule_179_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    18 => {
                        let __invoking_marker = self.base.push_invoking_state(2365isize);
                        let __child = self.parse_generated_rule_188_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    19 => {
                        let __invoking_marker = self.base.push_invoking_state(2366isize);
                        let __child = self.parse_generated_rule_192_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    20 => {
                        let __invoking_marker = self.base.push_invoking_state(2367isize);
                        let __child = self.parse_generated_rule_193_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    21 => {
                        let __invoking_marker = self.base.push_invoking_state(2368isize);
                        let __child = self.parse_generated_rule_194_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    22 => {
                        let __invoking_marker = self.base.push_invoking_state(2369isize);
                        let __child = self.parse_generated_rule_195_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    23 => {
                        let __invoking_marker = self.base.push_invoking_state(2370isize);
                        let __child = self.parse_generated_rule_196_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    24 => {
                        let __match = self.base.match_token_recovering(130, 2373, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        match self.base.sync_decision(atn(), 2373, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2373) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(290, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(290, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2373, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __invoking_marker = self.base.push_invoking_state(2372isize);
                                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2372isize)).map_err(GeneratedRuleError::into_error) };
                                self.base.discard_invoking_state(__invoking_marker);
                                let __child = __child?;
                                self.base.add_parse_child(&mut __ctx, __child);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    25 => {
                        let __invoking_marker = self.base.push_invoking_state(2375isize);
                        let __child = self.parse_generated_rule_210_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    26 => {
                        let __invoking_marker = self.base.push_invoking_state(2376isize);
                        let __child = self.parse_generated_rule_211_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    27 => {
                        let __invoking_marker = self.base.push_invoking_state(2377isize);
                        let __child = self.parse_generated_rule_212_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    28 => {
                        let __invoking_marker = self.base.push_invoking_state(2378isize);
                        let __child = self.parse_generated_rule_213_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    29 => {
                        let __invoking_marker = self.base.push_invoking_state(2379isize);
                        let __child = self.parse_generated_rule_214_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    30 => {
                        let __invoking_marker = self.base.push_invoking_state(2380isize);
                        let __child = self.parse_generated_rule_216_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    31 => {
                        let __invoking_marker = self.base.push_invoking_state(2381isize);
                        let __child = self.parse_generated_rule_217_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    32 => {
                        let __invoking_marker = self.base.push_invoking_state(2382isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    33 => {
                        let __invoking_marker = self.base.push_invoking_state(2383isize);
                        let __child = self.parse_generated_rule_218_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    34 => {
                        let __invoking_marker = self.base.push_invoking_state(2384isize);
                        let __child = self.parse_generated_rule_219_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    35 => {
                        let __invoking_marker = self.base.push_invoking_state(2385isize);
                        let __child = self.parse_generated_rule_169_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                loop {
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.left_recursive_loop_enter_prediction(atn(), 2479, __precedence) {
                        Some(true) => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: true, diagnostic: None },
                        Some(false) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        None => {
                            let __prediction_precedence = if __precedence <= 0 { 0 } else { __precedence as usize };
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            match __simulator.adaptive_predict_stream_info_with_context(299, __prediction_precedence, self.base.input(), __prediction_context) {
                                Ok(__prediction) => __prediction,
                                Err(antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { .. }) => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: true, has_semantic_context: false, diagnostic: None },
                                Err(_) => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2479, &__prediction);
                    match __prediction.alt {
                        1 => {
                            self.base.parse_listener_exit_rule(148);
                            if let Some(__depth_error) = self.base.rule_depth_cap_violation() {
                                return Err(__depth_error);
                            }
                            self.base.push_new_recursion_context_with_previous(296isize, 148, &mut __ctx);
                            if let Some(__listener_error) = self.base.parse_listener_enter_rule(148) {
                                return Err(__listener_error);
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(298, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            match __prediction.alt {
                                1 => {
                                    if !self.base.precpred(44) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 44)"));
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = {
                                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                        __simulator.adaptive_predict_stream_info_with_context(292, 0, self.base.input(), __prediction_context)
                                            .map_err(|__error| match __error {
                                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                _ => self.base.no_viable_alternative_error(__decision_start),
                                            })?
                                    };
                                    match __prediction.alt {
                                        1 => {
                                            let __match = self.base.match_token_recovering(169, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        2 => {
                                            let __match = self.base.match_token_recovering(126, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        3 => {
                                            let __match = self.base.match_token_recovering(128, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        4 => {
                                            let __match = self.base.match_token_recovering(124, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        5 => {
                                            let __match = self.base.match_token_recovering(131, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        6 => {
                                            let __match = self.base.match_token_recovering(121, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        7 => {
                                            let __match = self.base.match_token_recovering(123, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        8 => {
                                            let __match = self.base.match_token_recovering(144, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        9 => {
                                            let __match = self.base.match_token_recovering(154, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        10 => {
                                            let __match = self.base.match_token_recovering(105, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        11 => {
                                            let __invoking_marker = self.base.push_invoking_state(2399isize);
                                            let __child = self.parse_generated_rule_240_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        12 => {
                                            let __invoking_marker = self.base.push_invoking_state(2400isize);
                                            let __child = self.parse_generated_rule_241_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        13 => {
                                            let __match = self.base.match_token_recovering(106, 2403, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(2404isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 45) } else { self.parse_generated_rule_148_adaptive_dispatch(45, false, Some(2404isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    if !self.base.precpred(41) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 41)"));
                                    }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = {
                                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                        __simulator.adaptive_predict_stream_info_with_context(293, 0, self.base.input(), __prediction_context)
                                            .map_err(|__error| match __error {
                                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                _ => self.base.no_viable_alternative_error(__decision_start),
                                            })?
                                    };
                                    match __prediction.alt {
                                        1 => {
                                            let __match = self.base.match_token_recovering(162, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        2 => {
                                            let __match = self.base.match_token_recovering(164, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        3 => {
                                            let __match = self.base.match_token_recovering(161, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        4 => {
                                            let __match = self.base.match_token_recovering(166, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        5 => {
                                            let __match = self.base.match_token_recovering(159, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        6 => {
                                            let __match = self.base.match_token_recovering(135, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        7 => {
                                            let __invoking_marker = self.base.push_invoking_state(2412isize);
                                            let __child = self.parse_generated_rule_238_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        8 => {
                                            let __invoking_marker = self.base.push_invoking_state(2413isize);
                                            let __child = self.parse_generated_rule_239_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        9 => {
                                            let __match = self.base.match_token_recovering(155, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        10 => {
                                            let __match = self.base.match_token_recovering(122, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        11 => {
                                            let __match = self.base.match_token_recovering(174, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        12 => {
                                            let __match = self.base.match_token_recovering(160, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        13 => {
                                            let __match = self.base.match_token_recovering(172, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        14 => {
                                            let __match = self.base.match_token_recovering(137, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        15 => {
                                            let __match = self.base.match_token_recovering(120, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        16 => {
                                            let __match = self.base.match_token_recovering(168, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        17 => {
                                            let __match = self.base.match_token_recovering(136, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        18 => {
                                            let __match = self.base.match_token_recovering(170, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        19 => {
                                            let __match = self.base.match_token_recovering(139, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        20 => {
                                            let __match = self.base.match_token_recovering(150, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        21 => {
                                            let __match = self.base.match_token_recovering(145, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        22 => {
                                            let __match = self.base.match_token_recovering(140, 2429, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(2430isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 42) } else { self.parse_generated_rule_148_adaptive_dispatch(42, false, Some(2430isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                3 => {
                                    if !self.base.precpred(37) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 37)"));
                                    }
                                    let __match = self.base.match_token_recovering(171, 2433, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2433isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 38) } else { self.parse_generated_rule_148_adaptive_dispatch(38, false, Some(2433isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                4 => {
                                    if !self.base.precpred(36) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 36)"));
                                    }
                                    let __match = self.base.match_token_recovering(171, 2436, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2436isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2436isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                    let __match = self.base.match_token_recovering(199, 2438, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2438isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 37) } else { self.parse_generated_rule_148_adaptive_dispatch(37, false, Some(2438isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                5 => {
                                    if !self.base.precpred(34) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 34)"));
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(2441isize);
                                    let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                6 => {
                                    if !self.base.precpred(25) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 25)"));
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(2443isize);
                                    let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                7 => {
                                    if !self.base.precpred(24) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 24)"));
                                    }
                                    let __match = self.base.match_token_recovering(150, 2446, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2446isize);
                                    let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                8 => {
                                    if !self.base.precpred(21) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 21)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(129, 129), (165, 165)], 2449, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2449isize);
                                    let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                9 => {
                                    if !self.base.precpred(18) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 18)"));
                                    }
                                    let __match = self.base.match_token_set_recovering(atn().token_set(14).expect("generated parser token-set index"), 2478, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                10 => {
                                    if !self.base.precpred(15) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 15)"));
                                    }
                                    let __match = self.base.match_token_recovering(130, 2455, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = {
                                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                        __simulator.adaptive_predict_stream_info_with_context(294, 0, self.base.input(), __prediction_context)
                                            .map_err(|__error| match __error {
                                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                _ => self.base.no_viable_alternative_error(__decision_start),
                                            })?
                                    };
                                    match __prediction.alt {
                                        1 => {
                                            let __invoking_marker = self.base.push_invoking_state(2454isize);
                                            let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2454isize)).map_err(GeneratedRuleError::into_error) };
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                        }
                                        2 => {
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                11 => {
                                    if !self.base.precpred(8) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 8)"));
                                    }
                                    let __match = self.base.match_token_recovering(55, 2459, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __match = self.base.match_token_recovering(197, 2471, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = {
                                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                        __simulator.adaptive_predict_stream_info_with_context(297, 0, self.base.input(), __prediction_context)
                                            .map_err(|__error| match __error {
                                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                _ => self.base.no_viable_alternative_error(__decision_start),
                                            })?
                                    };
                                    match __prediction.alt {
                                        1 => {
                                            let __invoking_marker = self.base.push_invoking_state(2460isize);
                                            let __child = self.parse_generated_rule_215_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                            self.base.discard_invoking_state(__invoking_marker);
                                            let __child = __child?;
                                            self.base.add_parse_child(&mut __ctx, __child);
                                            let mut __loop_iter_2465 = false;
                                            loop {
                                                match self.base.sync_decision(atn(), 2465, !__ctx.has_matched_child(), __loop_iter_2465) {
                                                    Ok(__sync_children) => {
                                                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                                    }
                                                    Err(__error) => {
                                                        __sync_error = Some(__error.clone());
                                                        return Err(__error);
                                                    }
                                                }
                                                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                                let __prediction = {
                                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                                    __simulator.adaptive_predict_stream_info_with_context(295, 0, self.base.input(), __prediction_context)
                                                        .map_err(|__error| match __error {
                                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                                        })?
                                                };
                                                self.base.record_generated_prediction_diagnostic(atn(), 2465, &__prediction);
                                                match __prediction.alt {
                                                    1 => {
                                                        __loop_iter_2465 = true;
                                                        let __match = self.base.match_token_recovering(163, 2462, atn())?;
                                                        __consumed_eof |= __match.consumed_eof();
                                                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                                        let __invoking_marker = self.base.push_invoking_state(2462isize);
                                                        let __child = self.parse_generated_rule_215_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                                        self.base.discard_invoking_state(__invoking_marker);
                                                        let __child = __child?;
                                                        self.base.add_parse_child(&mut __ctx, __child);
                                                    }
                                                    2 => {
                                                        break;
                                                    }
                                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                                }
                                            }
                                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                            let __prediction = {
                                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                                __simulator.adaptive_predict_stream_info_with_context(296, 0, self.base.input(), __prediction_context)
                                                    .map_err(|__error| match __error {
                                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                                    })?
                                            };
                                            match __prediction.alt {
                                                1 => {
                                                    let __match = self.base.match_token_recovering(163, 2470, atn())?;
                                                    __consumed_eof |= __match.consumed_eof();
                                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                                }
                                                2 => {
                                                }
                                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                            }
                                        }
                                        2 => {
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                    let __match = self.base.match_token_recovering(198, 2478, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                12 => {
                                    if !self.base.precpred(2) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 2)"));
                                    }
                                    let __match = self.base.match_token_recovering(103, 2476, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2476isize);
                                    let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => break,
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_149_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 149, GeneratedRuleError::Fatal; self.parse_generated_rule_149(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_149(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 298isize, 149, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9..=10 | 15 | 28 | 32..=33 | 37 | 39..=40 | 42..=43 | 46 | 50 | 53 | 58..=59 | 61 | 68 | 70..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 89 | 91..=93 | 95 | 100..=103 | 107..=108 | 110..=112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2484, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2484) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(300, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(300, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2484, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2482isize);
                        let __child = self.parse_generated_rule_150_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2483isize);
                        let __child = self.parse_generated_rule_151_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_150_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 150, GeneratedRuleError::Fatal; self.parse_generated_rule_150(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_150(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 300isize, 150, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2489 = false;
                loop {
                    match self.base.sync_decision(atn(), 2489, !__ctx.has_matched_child(), __loop_iter_2489) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        18 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2489, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2489 = true;
                            let __invoking_marker = self.base.push_invoking_state(2486isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(18, 2494, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2494, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    197 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2494, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2493isize);
                        let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2496isize);
                let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2498, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2498) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(303, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(303, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2498, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2497isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2497isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_151_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 151, GeneratedRuleError::Fatal; self.parse_generated_rule_151(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_151(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 302isize, 151, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    18 | 28 | 39 | 43 | 53 | 58 | 70 | 72..=73 | 75 | 82..=83 | 85 | 95 | 100..=101 | 111 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2502, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2502) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(304, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(304, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2502, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2500isize);
                        let __child = self.parse_generated_rule_152_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2501isize);
                        let __child = self.parse_generated_rule_153_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_152_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 152, GeneratedRuleError::Fatal; self.parse_generated_rule_152(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_152(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 304isize, 152, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2507 = false;
                loop {
                    match self.base.sync_decision(atn(), 2507, !__ctx.has_matched_child(), __loop_iter_2507) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 18 | 21 | 23..=26 | 28 | 32..=43 | 45..=46 | 48..=50 | 52..=53 | 57..=61 | 65 | 68..=73 | 75..=76 | 78 | 80 | 82..=83 | 85 | 88..=89 | 91..=93 | 95 | 97 | 100..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2507, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2507 = true;
                            let __invoking_marker = self.base.push_invoking_state(2504isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_2513 = false;
                loop {
                    match self.base.sync_decision(atn(), 2513, !__ctx.has_matched_child(), __loop_iter_2513) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2513) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(306, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(306, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2513, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2513 = true;
                            let __invoking_marker = self.base.push_invoking_state(2510isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 2517, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2517) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(307, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(307, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2517, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2516isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2519isize);
                let __child = self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(138, 2523, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=196 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2523, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2523) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(308, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(308, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2523, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2521isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2522isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2522isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_153_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 153, GeneratedRuleError::Fatal; self.parse_generated_rule_153(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_153(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 306isize, 153, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2528 = false;
                loop {
                    match self.base.sync_decision(atn(), 2528, !__ctx.has_matched_child(), __loop_iter_2528) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        4 | 9..=10 | 13 | 15..=16 | 21 | 23..=26 | 32..=38 | 40..=42 | 45..=46 | 48..=50 | 52 | 57 | 59..=61 | 65 | 68..=69 | 71 | 76 | 78 | 80 | 88..=89 | 91..=93 | 97 | 102..=103 | 107..=108 | 110 | 112..=114 | 116..=117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2528, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2528 = true;
                            let __invoking_marker = self.base.push_invoking_state(2525isize);
                            let __child = self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_2534 = false;
                loop {
                    match self.base.sync_decision(atn(), 2534, !__ctx.has_matched_child(), __loop_iter_2534) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2534) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(310, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(310, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2534, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2534 = true;
                            let __invoking_marker = self.base.push_invoking_state(2531isize);
                            let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(2537isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(138, 2541, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=196 | 200 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2541, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2541) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(311, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(311, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2541, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2539isize);
                        let __child = self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2540isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2540isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_154_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 154, GeneratedRuleError::Fatal; self.parse_generated_rule_154(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_154(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 308isize, 154, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 2544, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(197, 2556, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2556, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2556, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2545isize);
                        let __child = self.parse_generated_rule_155_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2550 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2550, !__ctx.has_matched_child(), __loop_iter_2550) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2550) {
                                __prediction
                            } else {
                                let __prediction = {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    __simulator.adaptive_predict_stream_info_sll_probe(312, 0, self.base.input())
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                };
                                if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                    __simulator.adaptive_predict_stream_info_with_context(312, 0, self.base.input(), __prediction_context)
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                } else {
                                    __prediction
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2550, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2550 = true;
                                    let __match = self.base.match_token_recovering(163, 2547, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2547isize);
                                    let __child = self.parse_generated_rule_155_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 2554, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2554, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(163, 2555, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(198, 2559, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_155_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 155, GeneratedRuleError::Fatal; self.parse_generated_rule_155(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_155(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 310isize, 155, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 2561, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2561) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(315, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(315, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2561, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2560isize);
                        let __child = self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2563isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2563isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_156_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 156, GeneratedRuleError::Fatal; self.parse_generated_rule_156(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_156(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 312isize, 156, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 2566, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2566isize);
                let __child = self.parse_generated_rule_77_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2568, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2568) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(316, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(316, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2568, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2567isize);
                        let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_157_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 157, GeneratedRuleError::Fatal; self.parse_generated_rule_157(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_157(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 314isize, 157, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(197, 2582, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2582, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2582, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2571isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2571isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2576 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2576, !__ctx.has_matched_child(), __loop_iter_2576) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2576) {
                                __prediction
                            } else {
                                let __prediction = {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    __simulator.adaptive_predict_stream_info_sll_probe(317, 0, self.base.input())
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                };
                                if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                    __simulator.adaptive_predict_stream_info_with_context(317, 0, self.base.input(), __prediction_context)
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                } else {
                                    __prediction
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2576, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2576 = true;
                                    let __match = self.base.match_token_recovering(163, 2573, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2573isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2573isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 2580, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2580, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(163, 2581, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(198, 2585, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_158_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 158, GeneratedRuleError::Fatal; self.parse_generated_rule_158(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_158(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 316isize, 158, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(61, 2587, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2587isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2587isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_159_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 159, GeneratedRuleError::Fatal; self.parse_generated_rule_159(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_159(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 318isize, 159, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                match self.base.sync_decision(atn(), 2591, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2591) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(320, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(320, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2591, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2589isize);
                        let __child = self.parse_generated_rule_160_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2590isize);
                        let __child = self.parse_generated_rule_161_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_160_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 160, GeneratedRuleError::Fatal; self.parse_generated_rule_160(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_160(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 320isize, 160, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 2594, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2594isize);
                let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2596, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2596) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(321, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(321, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2596, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2595isize);
                        let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_161_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 161, GeneratedRuleError::Fatal; self.parse_generated_rule_161(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_161(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 322isize, 161, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 2599, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2599isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2601, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2601) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(322, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(322, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2601, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2600isize);
                        let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2604, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2604) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(323, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(323, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2604, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2603isize);
                        let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_162_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 162, GeneratedRuleError::Fatal; self.parse_generated_rule_162(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_162(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 324isize, 162, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2607, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2607isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2609, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2609isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2609isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_163_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 163, GeneratedRuleError::Fatal; self.parse_generated_rule_163(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_163(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 326isize, 163, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2621, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            27 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            14 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2621, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(27, 2612, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __match = self.base.match_token_recovering(200, 2613, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2613isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2613isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(201, 2615, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(14, 2617, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __match = self.base.match_token_recovering(200, 2618, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2618isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2618isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let __match = self.base.match_token_recovering(201, 2620, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_164_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 164, GeneratedRuleError::Fatal; self.parse_generated_rule_164(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_164(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 328isize, 164, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(202, 2635, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2635, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=103 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 130 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2635, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2624isize);
                        let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2629 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2629, !__ctx.has_matched_child(), __loop_iter_2629) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2629) {
                                __prediction
                            } else {
                                let __prediction = {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    __simulator.adaptive_predict_stream_info_sll_probe(325, 0, self.base.input())
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                };
                                if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                    let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                    let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                    __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                    __simulator.adaptive_predict_stream_info_with_context(325, 0, self.base.input(), __prediction_context)
                                        .map_err(|__error| match __error {
                                            antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                            _ => self.base.no_viable_alternative_error(__decision_start),
                                        })?
                                } else {
                                    __prediction
                                }
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2629, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2629 = true;
                                    let __match = self.base.match_token_recovering(163, 2626, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    let __invoking_marker = self.base.push_invoking_state(2626isize);
                                    let __child = self.parse_generated_rule_165_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 2633, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 2633, &__prediction);
                        match __prediction.alt {
                            1 => {
                                let __match = self.base.match_token_recovering(163, 2634, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(203, 2638, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_165_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 165, GeneratedRuleError::Fatal; self.parse_generated_rule_165(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_165(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 330isize, 165, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3..=10 | 13..=16 | 18 | 21 | 23..=29 | 32..=43 | 45..=46 | 48..=53 | 56..=61 | 65 | 67..=76 | 78 | 80..=83 | 85 | 88..=89 | 91..=93 | 95..=102 | 107..=108 | 110..=114 | 116..=117 | 119 | 125 | 127 | 141 | 146 | 151..=153 | 156 | 160..=162 | 164..=165 | 172..=173 | 175..=186 | 194..=197 | 200 | 202 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2642, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2642) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(328, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(328, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2642, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2639isize);
                        let __child = self.parse_generated_rule_166_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2640isize);
                        let __child = self.parse_generated_rule_167_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2641isize);
                        let __child = self.parse_generated_rule_168_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_166_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 166, GeneratedRuleError::Fatal; self.parse_generated_rule_166(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_166(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 332isize, 166, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2644isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2644isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_167_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 167, GeneratedRuleError::Fatal; self.parse_generated_rule_167(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_167(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 334isize, 167, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(130, 2647, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2647isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2647isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_168_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 168, GeneratedRuleError::Fatal; self.parse_generated_rule_168(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_168(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 336isize, 168, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(103, 2650, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2650isize);
                let __child = self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_169_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 169, GeneratedRuleError::Fatal; self.parse_generated_rule_169(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_169(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 338isize, 169, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2652isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(2653isize);
                let __child = self.parse_generated_rule_117_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_170_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 170, GeneratedRuleError::Fatal; self.parse_generated_rule_170(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_170(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 340isize, 170, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(29, 2656, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2657, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2657isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2659, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_171_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 171, GeneratedRuleError::Fatal; self.parse_generated_rule_171(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_171(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 342isize, 171, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2660isize);
                let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_172_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 172, GeneratedRuleError::Fatal; self.parse_generated_rule_172(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_172(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 344isize, 172, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(68, 2663, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_173_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 173, GeneratedRuleError::Fatal; self.parse_generated_rule_173(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_173(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 346isize, 173, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(113, 2665, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(202, 2669, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_2669 = false;
                loop {
                    match self.base.sync_decision(atn(), 2669, !__ctx.has_matched_child(), __loop_iter_2669) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        203 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2669, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2669 = true;
                            let __match = self.base.match_token_recovering(163, 2668, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(203, 2673, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2673isize);
                let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_174_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 174, GeneratedRuleError::Fatal; self.parse_generated_rule_174(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_174(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 348isize, 174, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2675isize);
                let __child = self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_175_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 175, GeneratedRuleError::Fatal; self.parse_generated_rule_175(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_175(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 350isize, 175, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(5, 2678, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(202, 2679, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(203, 2680, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2680isize);
                let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_176_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 176, GeneratedRuleError::Fatal; self.parse_generated_rule_176(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_176(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 352isize, 176, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    81 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    98 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2684, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            81 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            98 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2684, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2682isize);
                        let __child = self.parse_generated_rule_177_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2683isize);
                        let __child = self.parse_generated_rule_178_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_177_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 177, GeneratedRuleError::Fatal; self.parse_generated_rule_177(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_177(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 354isize, 177, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(81, 2687, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_178_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 178, GeneratedRuleError::Fatal; self.parse_generated_rule_178(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_178(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 356isize, 178, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(98, 2689, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_179_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 179, GeneratedRuleError::Fatal; self.parse_generated_rule_179(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_179(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 358isize, 179, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    194 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    195 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2724, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2724) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(335, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(335, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2724, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(194, 2694, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_2694 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2694, !__ctx.has_matched_child(), __loop_iter_2694) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                1 | 197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                157 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2694, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2694 = true;
                                    let __invoking_marker = self.base.push_invoking_state(2691isize);
                                    let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(157, 2725, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(195, 2702, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let mut __loop_iter_2702 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2702, !__ctx.has_matched_child(), __loop_iter_2702) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                1 | 197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                157 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2702, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2702 = true;
                                    let __invoking_marker = self.base.push_invoking_state(2699isize);
                                    let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(157, 2725, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2706isize);
                        let __child = self.parse_generated_rule_185_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2710 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2710, !__ctx.has_matched_child(), __loop_iter_2710) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                1 | 197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2710, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2710 = true;
                                    let __invoking_marker = self.base.push_invoking_state(2707isize);
                                    let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(2713isize);
                        let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(2715isize);
                        let __child = self.parse_generated_rule_187_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                        let mut __loop_iter_2719 = false;
                        loop {
                            match self.base.sync_decision(atn(), 2719, !__ctx.has_matched_child(), __loop_iter_2719) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                Err(__error) => {
                                    __sync_error = Some(__error.clone());
                                    return Err(__error);
                                }
                            }
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                1 | 197 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 2719, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_2719 = true;
                                    let __invoking_marker = self.base.push_invoking_state(2716isize);
                                    let __child = self.parse_generated_rule_180_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(2722isize);
                        let __child = self.parse_generated_rule_186_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_180_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 180, GeneratedRuleError::Fatal; self.parse_generated_rule_180(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_180(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 360isize, 180, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    197 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2728, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            1 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            197 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2728, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2726isize);
                        let __child = self.parse_generated_rule_181_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2727isize);
                        let __child = self.parse_generated_rule_182_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_181_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 181, GeneratedRuleError::Fatal; self.parse_generated_rule_181(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_181(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 362isize, 181, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2730isize);
                let __child = self.parse_generated_rule_234_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_182_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 182, GeneratedRuleError::Fatal; self.parse_generated_rule_182(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_182(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 364isize, 182, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(197, 2733, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2733isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2733isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2735, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    198..=199 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2735, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2734isize);
                        let __child = self.parse_generated_rule_183_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 2738, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    199 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    198 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2738, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2737isize);
                        let __child = self.parse_generated_rule_184_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(198, 2741, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_183_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 183, GeneratedRuleError::Fatal; self.parse_generated_rule_183(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_183(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 366isize, 183, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(163, 2743, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2743isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2743isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_184_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 184, GeneratedRuleError::Fatal; self.parse_generated_rule_184(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_184(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 368isize, 184, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(199, 2746, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2746isize);
                let __child = self.parse_generated_rule_234_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_185_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 185, GeneratedRuleError::Fatal; self.parse_generated_rule_185(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_185(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 370isize, 185, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(196, 2749, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_186_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 186, GeneratedRuleError::Fatal; self.parse_generated_rule_186(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_186(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 372isize, 186, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(104, 2754, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let mut __loop_iter_2754 = false;
                loop {
                    match self.base.sync_decision(atn(), 2754, !__ctx.has_matched_child(), __loop_iter_2754) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2754) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(339, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(339, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2754, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2754 = true;
                            let __match = self.base.match_token_recovering(157, 2753, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_187_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 187, GeneratedRuleError::Fatal; self.parse_generated_rule_187(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_187(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 374isize, 187, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(196, 2758, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_188_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 188, GeneratedRuleError::Fatal; self.parse_generated_rule_188(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_188(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 376isize, 188, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    67 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    96 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    99 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    6 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    182 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    178..=181 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2772, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2772) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(340, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(340, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2772, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(29, 2773, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(67, 2773, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(96, 2773, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(99, 2773, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(6, 2773, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(2764isize);
                        let __child = self.parse_generated_rule_228_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(2765isize);
                        let __child = self.parse_generated_rule_235_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __invoking_marker = self.base.push_invoking_state(2766isize);
                        let __child = self.parse_generated_rule_223_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __invoking_marker = self.base.push_invoking_state(2767isize);
                        let __child = self.parse_generated_rule_236_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    10 => {
                        let __invoking_marker = self.base.push_invoking_state(2768isize);
                        let __child = self.parse_generated_rule_229_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    11 => {
                        let __invoking_marker = self.base.push_invoking_state(2769isize);
                        let __child = self.parse_generated_rule_189_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    12 => {
                        let __invoking_marker = self.base.push_invoking_state(2770isize);
                        let __child = self.parse_generated_rule_190_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    13 => {
                        let __invoking_marker = self.base.push_invoking_state(2771isize);
                        let __child = self.parse_generated_rule_191_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_189_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 189, GeneratedRuleError::Fatal; self.parse_generated_rule_189(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_189(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 378isize, 189, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2774isize);
                let __child = self.parse_generated_rule_235_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_set_recovering(&[(141, 141), (153, 153)], 2776, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_190_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 190, GeneratedRuleError::Fatal; self.parse_generated_rule_190(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_190(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 380isize, 190, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2777isize);
                let __child = self.parse_generated_rule_236_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_set_recovering(&[(141, 141), (153, 153)], 2779, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_191_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 191, GeneratedRuleError::Fatal; self.parse_generated_rule_191(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_191(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 382isize, 191, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2780isize);
                let __child = self.parse_generated_rule_229_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_set_recovering(&[(141, 141), (153, 153)], 2782, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_192_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 192, GeneratedRuleError::Fatal; self.parse_generated_rule_192(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_192(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 384isize, 192, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(7, 2784, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2785, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2785isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2785isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2787, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_193_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 193, GeneratedRuleError::Fatal; self.parse_generated_rule_193(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_193(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 386isize, 193, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(165, 2789, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2789isize);
                let __child = self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_194_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 194, GeneratedRuleError::Fatal; self.parse_generated_rule_194(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_194(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 388isize, 194, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2792, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2792isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2792isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2794, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_195_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 195, GeneratedRuleError::Fatal; self.parse_generated_rule_195(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_195(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 390isize, 195, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    156 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    160 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    161 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    162 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    125 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    164 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    127 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    172 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    175 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2813, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            156 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            160 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            161 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            162 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            125 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            164 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            127 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            172 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            175 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2813, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(156, 2796, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2796isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2796isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(160, 2798, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2798isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2798isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(161, 2800, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2800isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2800isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(162, 2802, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2802isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2802isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(125, 2804, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2804isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2804isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __match = self.base.match_token_recovering(164, 2806, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2806isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2806isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __match = self.base.match_token_recovering(127, 2808, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2808isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2808isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    8 => {
                        let __match = self.base.match_token_recovering(172, 2810, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2810isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2810isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    9 => {
                        let __match = self.base.match_token_recovering(175, 2812, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        let __invoking_marker = self.base.push_invoking_state(2812isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2812isize)).map_err(GeneratedRuleError::into_error) };
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_196_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 196, GeneratedRuleError::Fatal; self.parse_generated_rule_196(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_196(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 392isize, 196, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2815isize);
                let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(2816isize);
                let __child = self.parse_generated_rule_198_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_197_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 197, GeneratedRuleError::Fatal; self.parse_generated_rule_197(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_197(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 394isize, 197, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(89, 2820, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2820, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2820) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(342, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(342, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2820, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2819isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2822isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(149, 2824, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2824isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2824isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_198_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 198, GeneratedRuleError::Fatal; self.parse_generated_rule_198(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_198(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 396isize, 198, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_2829 = false;
                loop {
                    match self.base.sync_decision(atn(), 2829, !__ctx.has_matched_child(), __loop_iter_2829) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        33 | 78 | 89 | 93 | 112 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        50 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2829, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2829 = true;
                            let __invoking_marker = self.base.push_invoking_state(2826isize);
                            let __child = self.parse_generated_rule_199_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(2832isize);
                let __child = self.parse_generated_rule_206_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2834, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2834) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(344, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(344, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2834, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2833isize);
                        let __child = self.parse_generated_rule_209_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_199_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 199, GeneratedRuleError::Fatal; self.parse_generated_rule_199(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_199(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 398isize, 199, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    89 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    93 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    112 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    78 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2841, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            89 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            93 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            112 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            78 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2841, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2836isize);
                        let __child = self.parse_generated_rule_197_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2837isize);
                        let __child = self.parse_generated_rule_200_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2838isize);
                        let __child = self.parse_generated_rule_202_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(2839isize);
                        let __child = self.parse_generated_rule_203_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(2840isize);
                        let __child = self.parse_generated_rule_205_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_200_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 200, GeneratedRuleError::Fatal; self.parse_generated_rule_200(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_200(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 400isize, 200, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(93, 2845, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                match self.base.sync_decision(atn(), 2845, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2845) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(346, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(346, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2845, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2844isize);
                        let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(2847isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(149, 2849, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2849isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2849isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(151, 2851, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2851isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2851isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(40, 2853, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2853isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2853isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2855, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    92 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 | 50 | 71 | 78 | 89 | 93 | 112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2855, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2854isize);
                        let __child = self.parse_generated_rule_201_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_201_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 201, GeneratedRuleError::Fatal; self.parse_generated_rule_201(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_201(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 402isize, 201, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(92, 2858, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2858isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_202_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 202, GeneratedRuleError::Fatal; self.parse_generated_rule_202(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_202(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 404isize, 202, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(112, 2861, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2861isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(169, 2863, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2863isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2863isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_203_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 203, GeneratedRuleError::Fatal; self.parse_generated_rule_203(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_203(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 406isize, 203, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(33, 2866, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2866isize);
                let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2871 = false;
                loop {
                    match self.base.sync_decision(atn(), 2871, !__ctx.has_matched_child(), __loop_iter_2871) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        33 | 50 | 71 | 78 | 89 | 93 | 112 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2871, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2871 = true;
                            let __match = self.base.match_token_recovering(163, 2868, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(2868isize);
                            let __child = self.parse_generated_rule_204_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_204_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 204, GeneratedRuleError::Fatal; self.parse_generated_rule_204(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_204(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 408isize, 204, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2874isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2874isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2876, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 | 50 | 71 | 78 | 89 | 93 | 112 | 163 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2876, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_set_recovering(&[(4, 4), (9, 9)], 2877, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_205_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 205, GeneratedRuleError::Fatal; self.parse_generated_rule_205(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_205(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 410isize, 205, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(78, 2879, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2879isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2879isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_206_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 206, GeneratedRuleError::Fatal; self.parse_generated_rule_206(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_206(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 412isize, 206, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2883, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            50 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2883, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2881isize);
                        let __child = self.parse_generated_rule_207_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2882isize);
                        let __child = self.parse_generated_rule_208_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_207_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 207, GeneratedRuleError::Fatal; self.parse_generated_rule_207(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_207(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 414isize, 207, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(71, 2886, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2886isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2886isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(146, 2888, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2888isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2888isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_208_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 208, GeneratedRuleError::Fatal; self.parse_generated_rule_208(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_208(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 416isize, 208, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(50, 2891, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2891isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2891isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_209_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 209, GeneratedRuleError::Fatal; self.parse_generated_rule_209(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_209(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 418isize, 209, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(92, 2894, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2894isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(2895isize);
                let __child = self.parse_generated_rule_198_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_210_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 210, GeneratedRuleError::Fatal; self.parse_generated_rule_210(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_210(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 420isize, 210, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(116, 2898, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2898isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2898isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_211_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 211, GeneratedRuleError::Fatal; self.parse_generated_rule_211(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_211(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 422isize, 211, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(8, 2901, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2902, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2902isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2902isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2904, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_212_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 212, GeneratedRuleError::Fatal; self.parse_generated_rule_212(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_212(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 424isize, 212, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(3, 2906, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2907, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2907isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2907isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(163, 2909, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2909isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2911, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_213_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 213, GeneratedRuleError::Fatal; self.parse_generated_rule_213(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_213(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 426isize, 213, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(51, 2913, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2914, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2914isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2916, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_214_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 214, GeneratedRuleError::Fatal; self.parse_generated_rule_214(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_214(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 428isize, 214, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(5, 2918, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2918isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2920, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2920) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(351, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(351, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2920, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2919isize);
                        let __child = self.parse_generated_rule_157_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_215_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 215, GeneratedRuleError::Fatal; self.parse_generated_rule_215(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_215(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 430isize, 215, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(2922isize);
                let __child = self.parse_generated_rule_114_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 2924, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    102 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    138 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2924, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2923isize);
                        let __child = self.parse_generated_rule_135_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(138, 2927, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2927isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2927isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_216_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 216, GeneratedRuleError::Fatal; self.parse_generated_rule_216(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_216(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 432isize, 216, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(74, 2930, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2930isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2930isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_217_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 217, GeneratedRuleError::Fatal; self.parse_generated_rule_217(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_217(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 434isize, 217, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(200, 2933, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2933isize);
                let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(163, 2935, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2935isize);
                let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_2938 = true;
                loop {
                    match self.base.sync_decision(atn(), 2938, !__ctx.has_matched_child(), __loop_iter_2938) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        201 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 2938, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_2938 = true;
                            let __match = self.base.match_token_recovering(163, 2935, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(2935isize);
                            let __child = self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(201, 2941, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_218_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 218, GeneratedRuleError::Fatal; self.parse_generated_rule_218(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_218(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 436isize, 218, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(56, 2943, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2944, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2944isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2946, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_219_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 219, GeneratedRuleError::Fatal; self.parse_generated_rule_219(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_219(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 438isize, 219, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(57, 2948, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(200, 2949, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __invoking_marker = self.base.push_invoking_state(2949isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(148, 0) } else { self.parse_generated_rule_148_adaptive_dispatch(0, false, Some(2949isize)).map_err(GeneratedRuleError::into_error) };
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __match = self.base.match_token_recovering(201, 2951, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_220_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 220, GeneratedRuleError::Fatal; self.parse_generated_rule_220(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_220(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 440isize, 220, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    182 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9..=10 | 15 | 32..=33 | 37 | 40 | 42 | 46 | 50 | 59 | 61 | 68 | 71 | 76 | 78 | 80 | 89 | 91..=93 | 102..=103 | 107..=108 | 110 | 112 | 114 | 117 | 119 | 141 | 146 | 151..=153 | 173 | 176..=177 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5..=8 | 11..=14 | 16..=24 | 26..=31 | 35..=36 | 39 | 41 | 43..=45 | 47 | 49 | 51..=58 | 62..=67 | 69..=70 | 72..=75 | 77 | 79 | 81..=87 | 90 | 94..=96 | 98..=101 | 109 | 111 | 113 | 115..=116 | 118 | 147..=149 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    178..=181 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    105..=106 | 120..=128 | 131 | 135..=137 | 139..=140 | 144 | 154..=156 | 159..=162 | 164 | 166 | 168..=170 | 172 | 174..=175 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    129..=130 | 132..=134 | 138 | 142..=143 | 157..=158 | 163 | 165 | 167 | 171 | 197..=203 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    183..=184 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 2959, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 2959) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(354, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(354, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 2959, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(2952isize);
                        let __child = self.parse_generated_rule_228_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(2953isize);
                        let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __invoking_marker = self.base.push_invoking_state(2954isize);
                        let __child = self.parse_generated_rule_222_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    4 => {
                        let __invoking_marker = self.base.push_invoking_state(2955isize);
                        let __child = self.parse_generated_rule_223_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    5 => {
                        let __invoking_marker = self.base.push_invoking_state(2956isize);
                        let __child = self.parse_generated_rule_232_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    6 => {
                        let __invoking_marker = self.base.push_invoking_state(2957isize);
                        let __child = self.parse_generated_rule_233_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    7 => {
                        let __invoking_marker = self.base.push_invoking_state(2958isize);
                        let __child = self.parse_generated_rule_229_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_221_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 221, GeneratedRuleError::Fatal; self.parse_generated_rule_221(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_221(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 442isize, 221, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_set_recovering(atn().token_set(17).expect("generated parser token-set index"), 2962, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_222_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 222, GeneratedRuleError::Fatal; self.parse_generated_rule_222(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_222(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 444isize, 222, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    145 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    62 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    83 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    84 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    63 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    27 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    64 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    28 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    18 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    147 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    39 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    86 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    87 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    66 => antlr4_runtime::ParserAtnPrediction { alt: 19, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    19 => antlr4_runtime::ParserAtnPrediction { alt: 20, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    67 => antlr4_runtime::ParserAtnPrediction { alt: 21, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    30 => antlr4_runtime::ParserAtnPrediction { alt: 22, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    70 => antlr4_runtime::ParserAtnPrediction { alt: 23, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    109 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    31 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 26, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    148 => antlr4_runtime::ParserAtnPrediction { alt: 27, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    20 => antlr4_runtime::ParserAtnPrediction { alt: 28, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    149 => antlr4_runtime::ParserAtnPrediction { alt: 29, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    111 => antlr4_runtime::ParserAtnPrediction { alt: 30, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 => antlr4_runtime::ParserAtnPrediction { alt: 31, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    150 => antlr4_runtime::ParserAtnPrediction { alt: 32, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    94 => antlr4_runtime::ParserAtnPrediction { alt: 33, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    95 => antlr4_runtime::ParserAtnPrediction { alt: 34, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 35, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    96 => antlr4_runtime::ParserAtnPrediction { alt: 36, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    43 => antlr4_runtime::ParserAtnPrediction { alt: 37, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    22 => antlr4_runtime::ParserAtnPrediction { alt: 38, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    115 => antlr4_runtime::ParserAtnPrediction { alt: 39, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    44 => antlr4_runtime::ParserAtnPrediction { alt: 40, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    47 => antlr4_runtime::ParserAtnPrediction { alt: 41, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    72 => antlr4_runtime::ParserAtnPrediction { alt: 42, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    73 => antlr4_runtime::ParserAtnPrediction { alt: 43, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    51 => antlr4_runtime::ParserAtnPrediction { alt: 44, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    5 => antlr4_runtime::ParserAtnPrediction { alt: 45, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    53 => antlr4_runtime::ParserAtnPrediction { alt: 46, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    54 => antlr4_runtime::ParserAtnPrediction { alt: 47, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    55 => antlr4_runtime::ParserAtnPrediction { alt: 48, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    98 => antlr4_runtime::ParserAtnPrediction { alt: 49, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    74 => antlr4_runtime::ParserAtnPrediction { alt: 50, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    99 => antlr4_runtime::ParserAtnPrediction { alt: 51, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    118 => antlr4_runtime::ParserAtnPrediction { alt: 52, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    56 => antlr4_runtime::ParserAtnPrediction { alt: 53, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    100 => antlr4_runtime::ParserAtnPrediction { alt: 54, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    75 => antlr4_runtime::ParserAtnPrediction { alt: 55, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    14 => antlr4_runtime::ParserAtnPrediction { alt: 56, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    58 => antlr4_runtime::ParserAtnPrediction { alt: 57, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    77 => antlr4_runtime::ParserAtnPrediction { alt: 58, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    101 => antlr4_runtime::ParserAtnPrediction { alt: 59, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    79 => antlr4_runtime::ParserAtnPrediction { alt: 60, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    6 => antlr4_runtime::ParserAtnPrediction { alt: 61, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    7 => antlr4_runtime::ParserAtnPrediction { alt: 62, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    8 => antlr4_runtime::ParserAtnPrediction { alt: 63, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 => antlr4_runtime::ParserAtnPrediction { alt: 64, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 65, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 3028, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            145 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            81 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            82 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            62 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            83 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            84 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            27 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            64 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            17 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            28 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            29 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            18 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            147 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            39 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            86 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            87 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            66 => antlr4_runtime::ParserAtnPrediction { alt: 19, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            19 => antlr4_runtime::ParserAtnPrediction { alt: 20, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            67 => antlr4_runtime::ParserAtnPrediction { alt: 21, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            30 => antlr4_runtime::ParserAtnPrediction { alt: 22, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            70 => antlr4_runtime::ParserAtnPrediction { alt: 23, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            109 => antlr4_runtime::ParserAtnPrediction { alt: 24, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            31 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            90 => antlr4_runtime::ParserAtnPrediction { alt: 26, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            148 => antlr4_runtime::ParserAtnPrediction { alt: 27, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            20 => antlr4_runtime::ParserAtnPrediction { alt: 28, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            149 => antlr4_runtime::ParserAtnPrediction { alt: 29, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            111 => antlr4_runtime::ParserAtnPrediction { alt: 30, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            11 => antlr4_runtime::ParserAtnPrediction { alt: 31, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            150 => antlr4_runtime::ParserAtnPrediction { alt: 32, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            94 => antlr4_runtime::ParserAtnPrediction { alt: 33, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            95 => antlr4_runtime::ParserAtnPrediction { alt: 34, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            12 => antlr4_runtime::ParserAtnPrediction { alt: 35, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            96 => antlr4_runtime::ParserAtnPrediction { alt: 36, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            43 => antlr4_runtime::ParserAtnPrediction { alt: 37, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            22 => antlr4_runtime::ParserAtnPrediction { alt: 38, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            115 => antlr4_runtime::ParserAtnPrediction { alt: 39, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            44 => antlr4_runtime::ParserAtnPrediction { alt: 40, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            47 => antlr4_runtime::ParserAtnPrediction { alt: 41, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            72 => antlr4_runtime::ParserAtnPrediction { alt: 42, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            73 => antlr4_runtime::ParserAtnPrediction { alt: 43, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            51 => antlr4_runtime::ParserAtnPrediction { alt: 44, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            5 => antlr4_runtime::ParserAtnPrediction { alt: 45, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            53 => antlr4_runtime::ParserAtnPrediction { alt: 46, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            54 => antlr4_runtime::ParserAtnPrediction { alt: 47, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            55 => antlr4_runtime::ParserAtnPrediction { alt: 48, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            98 => antlr4_runtime::ParserAtnPrediction { alt: 49, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            74 => antlr4_runtime::ParserAtnPrediction { alt: 50, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            99 => antlr4_runtime::ParserAtnPrediction { alt: 51, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            118 => antlr4_runtime::ParserAtnPrediction { alt: 52, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            56 => antlr4_runtime::ParserAtnPrediction { alt: 53, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            100 => antlr4_runtime::ParserAtnPrediction { alt: 54, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            75 => antlr4_runtime::ParserAtnPrediction { alt: 55, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            14 => antlr4_runtime::ParserAtnPrediction { alt: 56, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            58 => antlr4_runtime::ParserAtnPrediction { alt: 57, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            77 => antlr4_runtime::ParserAtnPrediction { alt: 58, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            101 => antlr4_runtime::ParserAtnPrediction { alt: 59, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            79 => antlr4_runtime::ParserAtnPrediction { alt: 60, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            6 => antlr4_runtime::ParserAtnPrediction { alt: 61, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            7 => antlr4_runtime::ParserAtnPrediction { alt: 62, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            8 => antlr4_runtime::ParserAtnPrediction { alt: 63, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            3 => antlr4_runtime::ParserAtnPrediction { alt: 64, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            13 | 16 | 21 | 23..=26 | 34..=36 | 38 | 41 | 45 | 48..=49 | 52 | 57 | 60 | 65 | 69 | 88 | 97 | 113 | 116 => antlr4_runtime::ParserAtnPrediction { alt: 65, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3028, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(145, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(81, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(82, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(62, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(83, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        let __match = self.base.match_token_recovering(84, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        let __match = self.base.match_token_recovering(63, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    8 => {
                        let __match = self.base.match_token_recovering(85, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    9 => {
                        let __match = self.base.match_token_recovering(27, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    10 => {
                        let __match = self.base.match_token_recovering(64, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    11 => {
                        let __match = self.base.match_token_recovering(17, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    12 => {
                        let __match = self.base.match_token_recovering(28, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    13 => {
                        let __match = self.base.match_token_recovering(29, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    14 => {
                        let __match = self.base.match_token_recovering(18, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    15 => {
                        let __match = self.base.match_token_recovering(147, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    16 => {
                        let __match = self.base.match_token_recovering(39, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    17 => {
                        let __match = self.base.match_token_recovering(86, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    18 => {
                        let __match = self.base.match_token_recovering(87, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    19 => {
                        let __match = self.base.match_token_recovering(66, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    20 => {
                        let __match = self.base.match_token_recovering(19, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    21 => {
                        let __match = self.base.match_token_recovering(67, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    22 => {
                        let __match = self.base.match_token_recovering(30, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    23 => {
                        let __match = self.base.match_token_recovering(70, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    24 => {
                        let __match = self.base.match_token_recovering(109, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    25 => {
                        let __match = self.base.match_token_recovering(31, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    26 => {
                        let __match = self.base.match_token_recovering(90, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    27 => {
                        let __match = self.base.match_token_recovering(148, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    28 => {
                        let __match = self.base.match_token_recovering(20, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    29 => {
                        let __match = self.base.match_token_recovering(149, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    30 => {
                        let __match = self.base.match_token_recovering(111, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    31 => {
                        let __match = self.base.match_token_recovering(11, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    32 => {
                        let __match = self.base.match_token_recovering(150, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    33 => {
                        let __match = self.base.match_token_recovering(94, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    34 => {
                        let __match = self.base.match_token_recovering(95, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    35 => {
                        let __match = self.base.match_token_recovering(12, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    36 => {
                        let __match = self.base.match_token_recovering(96, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    37 => {
                        let __match = self.base.match_token_recovering(43, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    38 => {
                        let __match = self.base.match_token_recovering(22, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    39 => {
                        let __match = self.base.match_token_recovering(115, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    40 => {
                        let __match = self.base.match_token_recovering(44, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    41 => {
                        let __match = self.base.match_token_recovering(47, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    42 => {
                        let __match = self.base.match_token_recovering(72, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    43 => {
                        let __match = self.base.match_token_recovering(73, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    44 => {
                        let __match = self.base.match_token_recovering(51, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    45 => {
                        let __match = self.base.match_token_recovering(5, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    46 => {
                        let __match = self.base.match_token_recovering(53, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    47 => {
                        let __match = self.base.match_token_recovering(54, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    48 => {
                        let __match = self.base.match_token_recovering(55, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    49 => {
                        let __match = self.base.match_token_recovering(98, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    50 => {
                        let __match = self.base.match_token_recovering(74, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    51 => {
                        let __match = self.base.match_token_recovering(99, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    52 => {
                        let __match = self.base.match_token_recovering(118, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    53 => {
                        let __match = self.base.match_token_recovering(56, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    54 => {
                        let __match = self.base.match_token_recovering(100, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    55 => {
                        let __match = self.base.match_token_recovering(75, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    56 => {
                        let __match = self.base.match_token_recovering(14, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    57 => {
                        let __match = self.base.match_token_recovering(58, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    58 => {
                        let __match = self.base.match_token_recovering(77, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    59 => {
                        let __match = self.base.match_token_recovering(101, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    60 => {
                        let __match = self.base.match_token_recovering(79, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    61 => {
                        let __match = self.base.match_token_recovering(6, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    62 => {
                        let __match = self.base.match_token_recovering(7, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    63 => {
                        let __match = self.base.match_token_recovering(8, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    64 => {
                        let __match = self.base.match_token_recovering(3, 3029, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    65 => {
                        let __invoking_marker = self.base.push_invoking_state(3027isize);
                        let __child = self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_223_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 223, GeneratedRuleError::Fatal; self.parse_generated_rule_223(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_223(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 446isize, 223, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    178..=180 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    181 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 3032, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            178..=180 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            181 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3032, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(3030isize);
                        let __child = self.parse_generated_rule_224_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(3031isize);
                        let __child = self.parse_generated_rule_227_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_224_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 224, GeneratedRuleError::Fatal; self.parse_generated_rule_224(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_224(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 448isize, 224, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    178 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    179 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    180 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 3037, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            178 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            179 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            180 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3037, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(3034isize);
                        let __child = self.parse_generated_rule_225_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(3035isize);
                        let __child = self.parse_generated_rule_226_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(180, 3038, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_225_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 225, GeneratedRuleError::Fatal; self.parse_generated_rule_225(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_225(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 450isize, 225, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(178, 3040, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_226_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 226, GeneratedRuleError::Fatal; self.parse_generated_rule_226(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_226(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 452isize, 226, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(179, 3042, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_227_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 227, GeneratedRuleError::Fatal; self.parse_generated_rule_227(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_227(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 454isize, 227, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(181, 3044, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_228_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 228, GeneratedRuleError::Fatal; self.parse_generated_rule_228(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_228(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 456isize, 228, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(182, 3046, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_229_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 229, GeneratedRuleError::Fatal; self.parse_generated_rule_229(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_229(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 458isize, 229, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    183 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    184 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 3049, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            183 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            184 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3049, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(3047isize);
                        let __child = self.parse_generated_rule_230_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                        let __invoking_marker = self.base.push_invoking_state(3048isize);
                        let __child = self.parse_generated_rule_231_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_230_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 230, GeneratedRuleError::Fatal; self.parse_generated_rule_230(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_230(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 460isize, 230, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(183, 3052, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_231_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 231, GeneratedRuleError::Fatal; self.parse_generated_rule_231(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_231(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 462isize, 231, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(184, 3054, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_232_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 232, GeneratedRuleError::Fatal; self.parse_generated_rule_232(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_232(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 464isize, 232, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    156 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    120 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    159 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    121 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    122 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    160 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    123 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    161 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    162 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    125 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    126 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    164 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    127 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    128 => antlr4_runtime::ParserAtnPrediction { alt: 15, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    166 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    131 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    168 => antlr4_runtime::ParserAtnPrediction { alt: 18, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    135 => antlr4_runtime::ParserAtnPrediction { alt: 19, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    105 => antlr4_runtime::ParserAtnPrediction { alt: 20, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    136 => antlr4_runtime::ParserAtnPrediction { alt: 21, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    169 => antlr4_runtime::ParserAtnPrediction { alt: 22, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    137 => antlr4_runtime::ParserAtnPrediction { alt: 23, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    139 => antlr4_runtime::ParserAtnPrediction { alt: 25, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    140 => antlr4_runtime::ParserAtnPrediction { alt: 30, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    106 => antlr4_runtime::ParserAtnPrediction { alt: 31, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    145 => antlr4_runtime::ParserAtnPrediction { alt: 32, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    150 => antlr4_runtime::ParserAtnPrediction { alt: 33, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    172 => antlr4_runtime::ParserAtnPrediction { alt: 34, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    144 => antlr4_runtime::ParserAtnPrediction { alt: 35, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    174 => antlr4_runtime::ParserAtnPrediction { alt: 36, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    154 => antlr4_runtime::ParserAtnPrediction { alt: 37, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    155 => antlr4_runtime::ParserAtnPrediction { alt: 38, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    175 => antlr4_runtime::ParserAtnPrediction { alt: 39, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 3094, !__ctx.has_matched_child(), false) {
                            Ok(__sync_children) => {
                                for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            Err(__error) => {
                                __sync_error = Some(__error.clone());
                                return Err(__error);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 3094) {
                            __prediction
                        } else {
                            let __prediction = {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                __simulator.adaptive_predict_stream_info_sll_probe(359, 0, self.base.input())
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            };
                            if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                                let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                                let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                                __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                                __simulator.adaptive_predict_stream_info_with_context(359, 0, self.base.input(), __prediction_context)
                                    .map_err(|__error| match __error {
                                        antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                        _ => self.base.no_viable_alternative_error(__decision_start),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3094, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __match = self.base.match_token_recovering(156, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        let __match = self.base.match_token_recovering(120, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        let __match = self.base.match_token_recovering(159, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        let __match = self.base.match_token_recovering(121, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        let __match = self.base.match_token_recovering(122, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        let __match = self.base.match_token_recovering(160, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        let __match = self.base.match_token_recovering(123, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    8 => {
                        let __match = self.base.match_token_recovering(161, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    9 => {
                        let __match = self.base.match_token_recovering(124, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    10 => {
                        let __match = self.base.match_token_recovering(162, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    11 => {
                        let __match = self.base.match_token_recovering(125, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    12 => {
                        let __match = self.base.match_token_recovering(126, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    13 => {
                        let __match = self.base.match_token_recovering(164, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    14 => {
                        let __match = self.base.match_token_recovering(127, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    15 => {
                        let __match = self.base.match_token_recovering(128, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    16 => {
                        let __match = self.base.match_token_recovering(166, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    17 => {
                        let __match = self.base.match_token_recovering(131, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    18 => {
                        let __match = self.base.match_token_recovering(168, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    19 => {
                        let __match = self.base.match_token_recovering(135, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    20 => {
                        let __match = self.base.match_token_recovering(105, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    21 => {
                        let __match = self.base.match_token_recovering(136, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    22 => {
                        let __match = self.base.match_token_recovering(169, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    23 => {
                        let __match = self.base.match_token_recovering(137, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    24 => {
                        let __match = self.base.match_token_recovering(170, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    25 => {
                        let __match = self.base.match_token_recovering(139, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    26 => {
                        let __invoking_marker = self.base.push_invoking_state(3080isize);
                        let __child = self.parse_generated_rule_238_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    27 => {
                        let __invoking_marker = self.base.push_invoking_state(3081isize);
                        let __child = self.parse_generated_rule_240_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    28 => {
                        let __invoking_marker = self.base.push_invoking_state(3082isize);
                        let __child = self.parse_generated_rule_239_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    29 => {
                        let __invoking_marker = self.base.push_invoking_state(3083isize);
                        let __child = self.parse_generated_rule_241_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    30 => {
                        let __match = self.base.match_token_recovering(140, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    31 => {
                        let __match = self.base.match_token_recovering(106, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    32 => {
                        let __match = self.base.match_token_recovering(145, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    33 => {
                        let __match = self.base.match_token_recovering(150, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    34 => {
                        let __match = self.base.match_token_recovering(172, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    35 => {
                        let __match = self.base.match_token_recovering(144, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    36 => {
                        let __match = self.base.match_token_recovering(174, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    37 => {
                        let __match = self.base.match_token_recovering(154, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    38 => {
                        let __match = self.base.match_token_recovering(155, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    39 => {
                        let __match = self.base.match_token_recovering(175, 3095, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_233_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 233, GeneratedRuleError::Fatal; self.parse_generated_rule_233(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_233(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 466isize, 233, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_set_recovering(atn().token_set(18).expect("generated parser token-set index"), 3097, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_234_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 234, GeneratedRuleError::Fatal; self.parse_generated_rule_234(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_234(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 468isize, 234, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(1, 3099, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_235_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 235, GeneratedRuleError::Fatal; self.parse_generated_rule_235(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_235(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 470isize, 235, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(186, 3101, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_236_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 236, GeneratedRuleError::Fatal; self.parse_generated_rule_236(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_236(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 472isize, 236, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(185, 3103, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_237_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 237, GeneratedRuleError::Fatal; self.parse_generated_rule_237(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_237(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 474isize, 237, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(176, 3105, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_238_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 238, GeneratedRuleError::Fatal; self.parse_generated_rule_238(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_238(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 476isize, 238, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(170, 3107, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(170, 3108, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 238, 17, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(238, 17, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(238, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_239_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 239, GeneratedRuleError::Fatal; self.parse_generated_rule_239(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_239(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 478isize, 239, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(170, 3111, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(170, 3112, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 239, 18, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(239, 18, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(239, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
                let __match = self.base.match_token_recovering(170, 3114, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 239, 19, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(239, 19, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(239, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_240_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 240, GeneratedRuleError::Fatal; self.parse_generated_rule_240(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_240(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 480isize, 240, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(170, 3117, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(139, 3118, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 240, 20, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(240, 20, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(240, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_241_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 241, GeneratedRuleError::Fatal; self.parse_generated_rule_241(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_241(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 482isize, 241, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __match = self.base.match_token_recovering(170, 3121, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                let __match = self.base.match_token_recovering(170, 3122, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 241, 21, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(241, 21, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(241, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
                let __match = self.base.match_token_recovering(139, 3124, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 241, 22, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(241, 22, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(241, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_242_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 242, GeneratedRuleError::Fatal; self.parse_generated_rule_242(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_242(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 484isize, 242, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(3126isize);
                let __child = self.parse_generated_rule_76_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let __invoking_marker = self.base.push_invoking_state(3127isize);
                let __child = self.parse_generated_rule_243_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                let mut __loop_iter_3132 = false;
                loop {
                    match self.base.sync_decision(atn(), 3132, !__ctx.has_matched_child(), __loop_iter_3132) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        Err(__error) => {
                            __sync_error = Some(__error.clone());
                            return Err(__error);
                        }
                    }
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        163 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 3132, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_3132 = true;
                            let __match = self.base.match_token_recovering(163, 3129, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            let __invoking_marker = self.base.push_invoking_state(3129isize);
                            let __child = self.parse_generated_rule_243_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                            self.base.discard_invoking_state(__invoking_marker);
                            let __child = __child?;
                            self.base.add_parse_child(&mut __ctx, __child);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_243_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 243, GeneratedRuleError::Fatal; self.parse_generated_rule_243(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_243(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 486isize, 243, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [self.adaptive_atn_retry_slot.is_some() => GeneratedRuleError::AdaptiveRetry];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let __invoking_marker = self.base.push_invoking_state(3135isize);
                let __child = self.parse_generated_rule_221_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                self.base.discard_invoking_state(__invoking_marker);
                let __child = __child?;
                self.base.add_parse_child(&mut __ctx, __child);
                match self.base.sync_decision(atn(), 3137, !__ctx.has_matched_child(), false) {
                    Ok(__sync_children) => {
                        for __child in __sync_children { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    Err(__error) => {
                        __sync_error = Some(__error.clone());
                        return Err(__error);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    169 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    163 | 167 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                };
                self.base.record_generated_prediction_diagnostic(atn(), 3137, &__prediction);
                match __prediction.alt {
                    1 => {
                        let __invoking_marker = self.base.push_invoking_state(3136isize);
                        let __child = self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error);
                        self.base.discard_invoking_state(__invoking_marker);
                        let __child = __child?;
                        self.base.add_parse_child(&mut __ctx, __child);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }



    pub fn compilation_unit(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(0)
    }
    pub fn extern_alias_directive(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(1)
    }
    pub fn using_directive(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(2)
    }
    pub fn name_equals(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(3)
    }
    pub fn identifier_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(4)
    }
    pub fn attribute_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(5)
    }
    pub fn attribute_target_specifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(6)
    }
    pub fn attribute(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(7)
    }
    pub fn name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(8)
    }
    pub fn alias_qualified_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(9)
    }
    pub fn simple_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(10)
    }
    pub fn generic_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(11)
    }
    pub fn type_argument_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(12)
    }
    pub fn attribute_argument_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(13)
    }
    pub fn attribute_argument(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(14)
    }
    pub fn name_colon(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(15)
    }
    pub fn member_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(16)
    }
    pub fn base_field_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(17)
    }
    pub fn event_field_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(18)
    }
    pub fn modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(19)
    }
    pub fn variable_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(20)
    }
    pub fn variable_declarator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(21)
    }
    pub fn bracketed_argument_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(22)
    }
    pub fn argument(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(23)
    }
    pub fn equals_value_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(24)
    }
    pub fn field_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(25)
    }
    pub fn base_method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(26)
    }
    pub fn constructor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(27)
    }
    pub fn parameter_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(28)
    }
    pub fn parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(29)
    }
    pub fn constructor_initializer(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(30)
    }
    pub fn argument_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(31)
    }
    pub fn block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(32)
    }
    pub fn arrow_expression_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(33)
    }
    pub fn conversion_operator_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(34)
    }
    pub fn explicit_interface_specifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(35)
    }
    pub fn destructor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(36)
    }
    pub fn method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(37)
    }
    pub fn type_parameter_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(38)
    }
    pub fn type_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(39)
    }
    pub fn type_parameter_constraint_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(40)
    }
    pub fn type_parameter_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(41)
    }
    pub fn allows_constraint_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(42)
    }
    pub fn allows_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(43)
    }
    pub fn ref_struct_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(44)
    }
    pub fn class_or_struct_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(45)
    }
    pub fn constructor_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(46)
    }
    pub fn default_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(47)
    }
    pub fn type_constraint(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(48)
    }
    pub fn operator_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(49)
    }
    pub fn base_namespace_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(50)
    }
    pub fn file_scoped_namespace_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(51)
    }
    pub fn namespace_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(52)
    }
    pub fn base_property_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(53)
    }
    pub fn event_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(54)
    }
    pub fn accessor_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(55)
    }
    pub fn accessor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(56)
    }
    pub fn indexer_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(57)
    }
    pub fn bracketed_parameter_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(58)
    }
    pub fn property_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(59)
    }
    pub fn base_type_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(60)
    }
    pub fn enum_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(61)
    }
    pub fn base_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(62)
    }
    pub fn base_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(63)
    }
    pub fn primary_constructor_base_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(64)
    }
    pub fn simple_base_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(65)
    }
    pub fn enum_member_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(66)
    }
    pub fn type_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(67)
    }
    pub fn class_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(68)
    }
    pub fn extension_block_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(69)
    }
    pub fn interface_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(70)
    }
    pub fn record_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(71)
    }
    pub fn struct_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(72)
    }
    pub fn union_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(73)
    }
    pub fn delegate_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(74)
    }
    pub fn global_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(75)
    }
    pub fn r#type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(76)
    }
    pub fn array_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(77)
    }
    pub fn array_rank_specifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(78)
    }
    pub fn function_pointer_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(79)
    }
    pub fn function_pointer_calling_convention(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(80)
    }
    pub fn function_pointer_unmanaged_calling_convention_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(81)
    }
    pub fn function_pointer_unmanaged_calling_convention(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(82)
    }
    pub fn function_pointer_parameter_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(83)
    }
    pub fn function_pointer_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(84)
    }
    pub fn predefined_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(85)
    }
    pub fn ref_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(86)
    }
    pub fn scoped_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(87)
    }
    pub fn tuple_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(88)
    }
    pub fn tuple_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(89)
    }
    pub fn statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(90)
    }
    pub fn break_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(91)
    }
    pub fn checked_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(92)
    }
    pub fn common_for_each_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(93)
    }
    pub fn for_each_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(94)
    }
    pub fn for_each_variable_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(95)
    }
    pub fn continue_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(96)
    }
    pub fn do_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(97)
    }
    pub fn empty_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(98)
    }
    pub fn expression_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(99)
    }
    pub fn fixed_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(100)
    }
    pub fn for_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(101)
    }
    pub fn goto_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(102)
    }
    pub fn if_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(103)
    }
    pub fn else_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(104)
    }
    pub fn labeled_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(105)
    }
    pub fn local_declaration_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(106)
    }
    pub fn local_function_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(107)
    }
    pub fn lock_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(108)
    }
    pub fn return_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(109)
    }
    pub fn switch_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(110)
    }
    pub fn switch_section(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(111)
    }
    pub fn switch_label(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(112)
    }
    pub fn case_pattern_switch_label(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(113)
    }
    pub fn pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(114)
    }
    pub fn constant_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(115)
    }
    pub fn declaration_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(116)
    }
    pub fn variable_designation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(117)
    }
    pub fn discard_designation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(118)
    }
    pub fn parenthesized_variable_designation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(119)
    }
    pub fn single_variable_designation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(120)
    }
    pub fn discard_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(121)
    }
    pub fn list_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(122)
    }
    pub fn parenthesized_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(123)
    }
    pub fn recursive_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(124)
    }
    pub fn positional_pattern_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(125)
    }
    pub fn subpattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(126)
    }
    pub fn base_expression_colon(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(127)
    }
    pub fn expression_colon(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(128)
    }
    pub fn property_pattern_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(129)
    }
    pub fn relational_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(130)
    }
    pub fn slice_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(131)
    }
    pub fn type_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(132)
    }
    pub fn unary_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(133)
    }
    pub fn var_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(134)
    }
    pub fn when_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(135)
    }
    pub fn case_switch_label(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(136)
    }
    pub fn default_switch_label(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(137)
    }
    pub fn throw_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(138)
    }
    pub fn try_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(139)
    }
    pub fn catch_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(140)
    }
    pub fn catch_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(141)
    }
    pub fn catch_filter_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(142)
    }
    pub fn finally_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(143)
    }
    pub fn unsafe_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(144)
    }
    pub fn using_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(145)
    }
    pub fn while_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(146)
    }
    pub fn yield_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(147)
    }
    pub fn expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(148)
    }
    pub fn anonymous_function_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(149)
    }
    pub fn anonymous_method_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(150)
    }
    pub fn lambda_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(151)
    }
    pub fn parenthesized_lambda_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(152)
    }
    pub fn simple_lambda_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(153)
    }
    pub fn anonymous_object_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(154)
    }
    pub fn anonymous_object_member_declarator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(155)
    }
    pub fn array_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(156)
    }
    pub fn initializer_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(157)
    }
    pub fn await_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(158)
    }
    pub fn base_object_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(159)
    }
    pub fn implicit_object_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(160)
    }
    pub fn object_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(161)
    }
    pub fn cast_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(162)
    }
    pub fn checked_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(163)
    }
    pub fn collection_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(164)
    }
    pub fn collection_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(165)
    }
    pub fn expression_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(166)
    }
    pub fn spread_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(167)
    }
    pub fn with_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(168)
    }
    pub fn declaration_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(169)
    }
    pub fn default_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(170)
    }
    pub fn element_binding_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(171)
    }
    pub fn field_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(172)
    }
    pub fn implicit_array_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(173)
    }
    pub fn implicit_element_access(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(174)
    }
    pub fn implicit_stack_alloc_array_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(175)
    }
    pub fn instance_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(176)
    }
    pub fn base_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(177)
    }
    pub fn this_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(178)
    }
    pub fn interpolated_string_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(179)
    }
    pub fn interpolated_string_content(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(180)
    }
    pub fn interpolated_string_text(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(181)
    }
    pub fn interpolation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(182)
    }
    pub fn interpolation_alignment_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(183)
    }
    pub fn interpolation_format_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(184)
    }
    pub fn interpolated_multi_line_raw_string_start_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(185)
    }
    pub fn interpolated_raw_string_end_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(186)
    }
    pub fn interpolated_single_line_raw_string_start_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(187)
    }
    pub fn literal_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(188)
    }
    pub fn utf8_multi_line_raw_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(189)
    }
    pub fn utf8_single_line_raw_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(190)
    }
    pub fn utf8_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(191)
    }
    pub fn make_ref_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(192)
    }
    pub fn member_binding_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(193)
    }
    pub fn parenthesized_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(194)
    }
    pub fn prefix_unary_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(195)
    }
    pub fn query_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(196)
    }
    pub fn from_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(197)
    }
    pub fn query_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(198)
    }
    pub fn query_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(199)
    }
    pub fn join_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(200)
    }
    pub fn join_into_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(201)
    }
    pub fn let_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(202)
    }
    pub fn order_by_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(203)
    }
    pub fn ordering(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(204)
    }
    pub fn where_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(205)
    }
    pub fn select_or_group_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(206)
    }
    pub fn group_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(207)
    }
    pub fn select_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(208)
    }
    pub fn query_continuation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(209)
    }
    pub fn ref_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(210)
    }
    pub fn ref_type_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(211)
    }
    pub fn ref_value_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(212)
    }
    pub fn size_of_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(213)
    }
    pub fn stack_alloc_array_creation_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(214)
    }
    pub fn switch_expression_arm(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(215)
    }
    pub fn throw_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(216)
    }
    pub fn tuple_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(217)
    }
    pub fn type_of_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(218)
    }
    pub fn unsafe_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(219)
    }
    pub fn syntax_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(220)
    }
    pub fn identifier_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(221)
    }
    pub fn keyword(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(222)
    }
    pub fn numeric_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(223)
    }
    pub fn integer_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(224)
    }
    pub fn decimal_integer_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(225)
    }
    pub fn hexadecimal_integer_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(226)
    }
    pub fn real_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(227)
    }
    pub fn character_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(228)
    }
    pub fn string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(229)
    }
    pub fn regular_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(230)
    }
    pub fn verbatim_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(231)
    }
    pub fn operator_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(232)
    }
    pub fn punctuation_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(233)
    }
    pub fn interpolated_string_text_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(234)
    }
    pub fn multi_line_raw_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(235)
    }
    pub fn single_line_raw_string_literal_token(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(236)
    }
    pub fn record_keyword(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(237)
    }
    pub fn right_shift(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(238)
    }
    pub fn unsigned_right_shift(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(239)
    }
    pub fn right_shift_assignment(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(240)
    }
    pub fn unsigned_right_shift_assignment(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(241)
    }
    pub fn local_variable_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(242)
    }
    pub fn local_variable_declarator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(243)
    }


    fn run_action(&mut self, action: antlr4_runtime::ParserAction, tree: antlr4_runtime::ParseTree) {
        match action.source_state() {
            561 => {}
            1613 => {}
            2080 => {}
            2347 => {}
            _ => { let _ = self.base.parser_action_hook(action, tree); }
        }
    }

}



antlr4_runtime::__antlr4_rust_parser_facade! {
    type: CSharpParser<L, H>,
    fields: {
        base: base,
        simulator: simulator,
        generated_only: generated_only,
    },
    metadata: metadata,
    parser_atn: parser_atn,
    reset(parser) {
        parser.adaptive_atn_preferred_rules.fill(false);
        parser.adaptive_atn_preference_depths.fill(0);
        parser.adaptive_atn_preference_starts.fill((0, 0));
        parser.adaptive_atn_syntax_error_starts.fill(0);
        parser.adaptive_atn_retry_slot = None;
    }
}
}

#[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)]
pub use self::__antlr4_rust_generated::*;
