// @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 ABSTRACT: i32 = 1;
pub const ASSERT: i32 = 2;
pub const BOOLEAN: i32 = 3;
pub const BREAK: i32 = 4;
pub const BYTE: i32 = 5;
pub const CASE: i32 = 6;
pub const CATCH: i32 = 7;
pub const CHAR: i32 = 8;
pub const CLASS: i32 = 9;
pub const CONST: i32 = 10;
pub const CONTINUE: i32 = 11;
pub const DEFAULT: i32 = 12;
pub const DO: i32 = 13;
pub const DOUBLE: i32 = 14;
pub const ELSE: i32 = 15;
pub const ENUM: i32 = 16;
pub const EXPORTS: i32 = 17;
pub const EXTENDS: i32 = 18;
pub const FINAL: i32 = 19;
pub const FINALLY: i32 = 20;
pub const FLOAT: i32 = 21;
pub const FOR: i32 = 22;
pub const GOTO: i32 = 23;
pub const IF: i32 = 24;
pub const IMPLEMENTS: i32 = 25;
pub const IMPORT: i32 = 26;
pub const INSTANCEOF: i32 = 27;
pub const INT: i32 = 28;
pub const INTERFACE: i32 = 29;
pub const LONG: i32 = 30;
pub const MODULE: i32 = 31;
pub const NATIVE: i32 = 32;
pub const NEW: i32 = 33;
pub const NON_SEALED: i32 = 34;
pub const OPEN: i32 = 35;
pub const OPENS: i32 = 36;
pub const PACKAGE: i32 = 37;
pub const PERMITS: i32 = 38;
pub const PRIVATE: i32 = 39;
pub const PROTECTED: i32 = 40;
pub const PROVIDES: i32 = 41;
pub const PUBLIC: i32 = 42;
pub const RECORD: i32 = 43;
pub const REQUIRES: i32 = 44;
pub const RETURN: i32 = 45;
pub const SEALED: i32 = 46;
pub const SHORT: i32 = 47;
pub const STATIC: i32 = 48;
pub const STRICTFP: i32 = 49;
pub const SUPER: i32 = 50;
pub const SWITCH: i32 = 51;
pub const SYNCHRONIZED: i32 = 52;
pub const THIS: i32 = 53;
pub const THROW: i32 = 54;
pub const THROWS: i32 = 55;
pub const TO: i32 = 56;
pub const TRANSIENT: i32 = 57;
pub const TRANSITIVE: i32 = 58;
pub const TRY: i32 = 59;
pub const USES: i32 = 60;
pub const VAR: i32 = 61;
pub const VOID: i32 = 62;
pub const VOLATILE: i32 = 63;
pub const WHEN: i32 = 64;
pub const WHILE: i32 = 65;
pub const WITH: i32 = 66;
pub const YIELD: i32 = 67;
pub const DECIMAL_LITERAL: i32 = 68;
pub const HEX_LITERAL: i32 = 69;
pub const OCT_LITERAL: i32 = 70;
pub const BINARY_LITERAL: i32 = 71;
pub const FLOAT_LITERAL: i32 = 72;
pub const HEX_FLOAT_LITERAL: i32 = 73;
pub const BOOL_LITERAL: i32 = 74;
pub const CHAR_LITERAL: i32 = 75;
pub const STRING_LITERAL: i32 = 76;
pub const TEXT_BLOCK: i32 = 77;
pub const NULL_LITERAL: i32 = 78;
pub const LPAREN: i32 = 79;
pub const RPAREN: i32 = 80;
pub const LBRACE: i32 = 81;
pub const RBRACE: i32 = 82;
pub const LBRACK: i32 = 83;
pub const RBRACK: i32 = 84;
pub const SEMI: i32 = 85;
pub const COMMA: i32 = 86;
pub const DOT: i32 = 87;
pub const ASSIGN: i32 = 88;
pub const GT: i32 = 89;
pub const LT: i32 = 90;
pub const BANG: i32 = 91;
pub const TILDE: i32 = 92;
pub const QUESTION: i32 = 93;
pub const COLON: i32 = 94;
pub const EQUAL: i32 = 95;
pub const LE: i32 = 96;
pub const GE: i32 = 97;
pub const NOTEQUAL: i32 = 98;
pub const AND: i32 = 99;
pub const OR: i32 = 100;
pub const INC: i32 = 101;
pub const DEC: i32 = 102;
pub const ADD: i32 = 103;
pub const SUB: i32 = 104;
pub const MUL: i32 = 105;
pub const DIV: i32 = 106;
pub const BITAND: i32 = 107;
pub const BITOR: i32 = 108;
pub const CARET: i32 = 109;
pub const MOD: i32 = 110;
pub const ADD_ASSIGN: i32 = 111;
pub const SUB_ASSIGN: i32 = 112;
pub const MUL_ASSIGN: i32 = 113;
pub const DIV_ASSIGN: i32 = 114;
pub const AND_ASSIGN: i32 = 115;
pub const OR_ASSIGN: i32 = 116;
pub const XOR_ASSIGN: i32 = 117;
pub const MOD_ASSIGN: i32 = 118;
pub const LSHIFT_ASSIGN: i32 = 119;
pub const RSHIFT_ASSIGN: i32 = 120;
pub const URSHIFT_ASSIGN: i32 = 121;
pub const ARROW: i32 = 122;
pub const COLONCOLON: i32 = 123;
pub const AT: i32 = 124;
pub const ELLIPSIS: i32 = 125;
pub const WS: i32 = 126;
pub const COMMENT: i32 = 127;
pub const LINE_COMMENT: i32 = 128;
pub const IDENTIFIER: i32 = 129;

pub const RULE_COMPILATION_UNIT: usize = 0;
pub const RULE_MODULAR_COMPULATION_UNIT: usize = 1;
pub const RULE_PACKAGE_DECLARATION: usize = 2;
pub const RULE_IMPORT_DECLARATION: usize = 3;
pub const RULE_TYPE_DECLARATION: usize = 4;
pub const RULE_MODIFIER: usize = 5;
pub const RULE_CLASS_OR_INTERFACE_MODIFIER: usize = 6;
pub const RULE_VARIABLE_MODIFIER: usize = 7;
pub const RULE_CLASS_DECLARATION: usize = 8;
pub const RULE_TYPE_PARAMETERS: usize = 9;
pub const RULE_TYPE_PARAMETER: usize = 10;
pub const RULE_TYPE_BOUND: usize = 11;
pub const RULE_ENUM_DECLARATION: usize = 12;
pub const RULE_ENUM_CONSTANTS: usize = 13;
pub const RULE_ENUM_CONSTANT: usize = 14;
pub const RULE_ENUM_BODY_DECLARATIONS: usize = 15;
pub const RULE_INTERFACE_DECLARATION: usize = 16;
pub const RULE_CLASS_BODY: usize = 17;
pub const RULE_INTERFACE_BODY: usize = 18;
pub const RULE_CLASS_BODY_DECLARATION: usize = 19;
pub const RULE_MEMBER_DECLARATION: usize = 20;
pub const RULE_METHOD_DECLARATION: usize = 21;
pub const RULE_METHOD_BODY: usize = 22;
pub const RULE_TYPE_TYPE_OR_VOID: usize = 23;
pub const RULE_GENERIC_METHOD_DECLARATION: usize = 24;
pub const RULE_GENERIC_CONSTRUCTOR_DECLARATION: usize = 25;
pub const RULE_CONSTRUCTOR_DECLARATION: usize = 26;
pub const RULE_COMPACT_CONSTRUCTOR_DECLARATION: usize = 27;
pub const RULE_FIELD_DECLARATION: usize = 28;
pub const RULE_INTERFACE_BODY_DECLARATION: usize = 29;
pub const RULE_INTERFACE_MEMBER_DECLARATION: usize = 30;
pub const RULE_CONST_DECLARATION: usize = 31;
pub const RULE_CONSTANT_DECLARATOR: usize = 32;
pub const RULE_INTERFACE_METHOD_DECLARATION: usize = 33;
pub const RULE_INTERFACE_METHOD_MODIFIER: usize = 34;
pub const RULE_GENERIC_INTERFACE_METHOD_DECLARATION: usize = 35;
pub const RULE_INTERFACE_COMMON_BODY_DECLARATION: usize = 36;
pub const RULE_VARIABLE_DECLARATORS: usize = 37;
pub const RULE_VARIABLE_DECLARATOR: usize = 38;
pub const RULE_VARIABLE_DECLARATOR_ID: usize = 39;
pub const RULE_VARIABLE_INITIALIZER: usize = 40;
pub const RULE_ARRAY_INITIALIZER: usize = 41;
pub const RULE_CLASS_TYPE: usize = 42;
pub const RULE_PACKAGE_NAME: usize = 43;
pub const RULE_TYPE_ARGUMENT: usize = 44;
pub const RULE_QUALIFIED_NAME_LIST: usize = 45;
pub const RULE_FORMAL_PARAMETERS: usize = 46;
pub const RULE_RECEIVER_PARAMETER: usize = 47;
pub const RULE_FORMAL_PARAMETER_LIST: usize = 48;
pub const RULE_FORMAL_PARAMETER: usize = 49;
pub const RULE_LAMBDA_LVTI_LIST: usize = 50;
pub const RULE_LAMBDA_LVTI_PARAMETER: usize = 51;
pub const RULE_QUALIFIED_NAME: usize = 52;
pub const RULE_LITERAL: usize = 53;
pub const RULE_INTEGER_LITERAL: usize = 54;
pub const RULE_FLOAT_LITERAL: usize = 55;
pub const RULE_ANNOTATION: usize = 56;
pub const RULE_ANNOTATION_FIELD_VALUES: usize = 57;
pub const RULE_ANNOTATION_FIELD_VALUE: usize = 58;
pub const RULE_ANNOTATION_VALUE: usize = 59;
pub const RULE_ELEMENT_VALUE: usize = 60;
pub const RULE_ELEMENT_VALUE_ARRAY_INITIALIZER: usize = 61;
pub const RULE_ANNOTATION_TYPE_DECLARATION: usize = 62;
pub const RULE_ANNOTATION_TYPE_BODY: usize = 63;
pub const RULE_ANNOTATION_TYPE_ELEMENT_DECLARATION: usize = 64;
pub const RULE_ANNOTATION_TYPE_ELEMENT_REST: usize = 65;
pub const RULE_ANNOTATION_METHOD_OR_CONSTANT_REST: usize = 66;
pub const RULE_ANNOTATION_METHOD_REST: usize = 67;
pub const RULE_ANNOTATION_CONSTANT_REST: usize = 68;
pub const RULE_DEFAULT_VALUE: usize = 69;
pub const RULE_MODULE_DECLARATION: usize = 70;
pub const RULE_MODULE_DIRECTIVE: usize = 71;
pub const RULE_REQUIRES_MODIFIER: usize = 72;
pub const RULE_RECORD_DECLARATION: usize = 73;
pub const RULE_RECORD_HEADER: usize = 74;
pub const RULE_RECORD_COMPONENT_LIST: usize = 75;
pub const RULE_RECORD_COMPONENT: usize = 76;
pub const RULE_RECORD_BODY: usize = 77;
pub const RULE_BLOCK: usize = 78;
pub const RULE_BLOCK_STATEMENT: usize = 79;
pub const RULE_LOCAL_VARIABLE_DECLARATION: usize = 80;
pub const RULE_IDENTIFIER: usize = 81;
pub const RULE_TYPE_IDENTIFIER: usize = 82;
pub const RULE_LOCAL_TYPE_DECLARATION: usize = 83;
pub const RULE_STATEMENT: usize = 84;
pub const RULE_CATCH_CLAUSE: usize = 85;
pub const RULE_CATCH_TYPE: usize = 86;
pub const RULE_FINALLY_BLOCK: usize = 87;
pub const RULE_RESOURCE_SPECIFICATION: usize = 88;
pub const RULE_RESOURCES: usize = 89;
pub const RULE_RESOURCE: usize = 90;
pub const RULE_SWITCH_BLOCK_STATEMENT_GROUP: usize = 91;
pub const RULE_SWITCH_LABEL: usize = 92;
pub const RULE_FOR_CONTROL: usize = 93;
pub const RULE_FOR_INIT: usize = 94;
pub const RULE_ENHANCED_FOR_CONTROL: usize = 95;
pub const RULE_EXPRESSION_LIST: usize = 96;
pub const RULE_METHOD_CALL: usize = 97;
pub const RULE_EXPRESSION: usize = 98;
pub const RULE_PATTERN: usize = 99;
pub const RULE_COMPONENT_PATTERN_LIST: usize = 100;
pub const RULE_COMPONENT_PATTERN: usize = 101;
pub const RULE_LAMBDA_EXPRESSION: usize = 102;
pub const RULE_LAMBDA_PARAMETERS: usize = 103;
pub const RULE_LAMBDA_BODY: usize = 104;
pub const RULE_PRIMARY: usize = 105;
pub const RULE_SWITCH_EXPRESSION: usize = 106;
pub const RULE_SWITCH_LABELED_RULE: usize = 107;
pub const RULE_GUARD: usize = 108;
pub const RULE_CASE_PATTERN: usize = 109;
pub const RULE_SWITCH_RULE_OUTCOME: usize = 110;
pub const RULE_CLASS_OR_INTERFACE_TYPE: usize = 111;
pub const RULE_CREATOR: usize = 112;
pub const RULE_CREATED_NAME: usize = 113;
pub const RULE_INNER_CREATOR: usize = 114;
pub const RULE_ARRAY_CREATOR_REST: usize = 115;
pub const RULE_CLASS_CREATOR_REST: usize = 116;
pub const RULE_EXPLICIT_GENERIC_INVOCATION: usize = 117;
pub const RULE_TYPE_ARGUMENTS_OR_DIAMOND: usize = 118;
pub const RULE_NON_WILDCARD_TYPE_ARGUMENTS_OR_DIAMOND: usize = 119;
pub const RULE_NON_WILDCARD_TYPE_ARGUMENTS: usize = 120;
pub const RULE_TYPE_LIST: usize = 121;
pub const RULE_TYPE_TYPE: usize = 122;
pub const RULE_PRIMITIVE_TYPE: usize = 123;
pub const RULE_TYPE_ARGUMENTS: usize = 124;
pub const RULE_SUPER_SUFFIX: usize = 125;
pub const RULE_EXPLICIT_GENERIC_INVOCATION_SUFFIX: usize = 126;
pub const RULE_ARGUMENTS: usize = 127;

pub static METADATA: GrammarMetadata = GrammarMetadata::new(
    "JavaParser",
    &["compilationUnit", "modularCompulationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration", "modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration", "typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants", "enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration", "methodDeclaration", "methodBody", "typeTypeOrVoid", "genericMethodDeclaration", "genericConstructorDeclaration", "constructorDeclaration", "compactConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", "interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", "interfaceMethodDeclaration", "interfaceMethodModifier", "genericInterfaceMethodDeclaration", "interfaceCommonBodyDeclaration", "variableDeclarators", "variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer", "classType", "packageName", "typeArgument", "qualifiedNameList", "formalParameters", "receiverParameter", "formalParameterList", "formalParameter", "lambdaLVTIList", "lambdaLVTIParameter", "qualifiedName", "literal", "integerLiteral", "floatLiteral", "annotation", "annotationFieldValues", "annotationFieldValue", "annotationValue", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration", "annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest", "annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest", "defaultValue", "moduleDeclaration", "moduleDirective", "requiresModifier", "recordDeclaration", "recordHeader", "recordComponentList", "recordComponent", "recordBody", "block", "blockStatement", "localVariableDeclaration", "identifier", "typeIdentifier", "localTypeDeclaration", "statement", "catchClause", "catchType", "finallyBlock", "resourceSpecification", "resources", "resource", "switchBlockStatementGroup", "switchLabel", "forControl", "forInit", "enhancedForControl", "expressionList", "methodCall", "expression", "pattern", "componentPatternList", "componentPattern", "lambdaExpression", "lambdaParameters", "lambdaBody", "primary", "switchExpression", "switchLabeledRule", "guard", "casePattern", "switchRuleOutcome", "classOrInterfaceType", "creator", "createdName", "innerCreator", "arrayCreatorRest", "classCreatorRest", "explicitGenericInvocation", "typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", "typeList", "typeType", "primitiveType", "typeArguments", "superSuffix", "explicitGenericInvocationSuffix", "arguments"],
    &[None, Some("\'abstract\'"), Some("\'assert\'"), Some("\'boolean\'"), Some("\'break\'"), Some("\'byte\'"), Some("\'case\'"), Some("\'catch\'"), Some("\'char\'"), Some("\'class\'"), Some("\'const\'"), Some("\'continue\'"), Some("\'default\'"), Some("\'do\'"), Some("\'double\'"), Some("\'else\'"), Some("\'enum\'"), Some("\'exports\'"), Some("\'extends\'"), Some("\'final\'"), Some("\'finally\'"), Some("\'float\'"), Some("\'for\'"), Some("\'goto\'"), Some("\'if\'"), Some("\'implements\'"), Some("\'import\'"), Some("\'instanceof\'"), Some("\'int\'"), Some("\'interface\'"), Some("\'long\'"), Some("\'module\'"), Some("\'native\'"), Some("\'new\'"), Some("\'non-sealed\'"), Some("\'open\'"), Some("\'opens\'"), Some("\'package\'"), Some("\'permits\'"), Some("\'private\'"), Some("\'protected\'"), Some("\'provides\'"), Some("\'public\'"), Some("\'record\'"), Some("\'requires\'"), Some("\'return\'"), Some("\'sealed\'"), Some("\'short\'"), Some("\'static\'"), Some("\'strictfp\'"), Some("\'super\'"), Some("\'switch\'"), Some("\'synchronized\'"), Some("\'this\'"), Some("\'throw\'"), Some("\'throws\'"), Some("\'to\'"), Some("\'transient\'"), Some("\'transitive\'"), Some("\'try\'"), Some("\'uses\'"), Some("\'var\'"), Some("\'void\'"), Some("\'volatile\'"), Some("\'when\'"), Some("\'while\'"), Some("\'with\'"), Some("\'yield\'"), None, None, None, None, None, None, None, None, None, None, Some("\'null\'"), Some("\'(\'"), Some("\')\'"), Some("\'{\'"), Some("\'}\'"), Some("\'[\'"), Some("\']\'"), Some("\';\'"), Some("\',\'"), Some("\'.\'"), Some("\'=\'"), Some("\'>\'"), Some("\'<\'"), Some("\'!\'"), Some("\'~\'"), Some("\'?\'"), Some("\':\'"), Some("\'==\'"), Some("\'<=\'"), Some("\'>=\'"), Some("\'!=\'"), Some("\'&&\'"), Some("\'||\'"), Some("\'++\'"), Some("\'--\'"), Some("\'+\'"), Some("\'-\'"), Some("\'*\'"), Some("\'/\'"), Some("\'&\'"), Some("\'|\'"), Some("\'^\'"), Some("\'%\'"), Some("\'+=\'"), Some("\'-=\'"), Some("\'*=\'"), Some("\'/=\'"), Some("\'&=\'"), Some("\'|=\'"), Some("\'^=\'"), Some("\'%=\'"), Some("\'<<=\'"), Some("\'>>=\'"), Some("\'>>>=\'"), Some("\'->\'"), Some("\'::\'"), Some("\'@\'"), Some("\'...\'"), None, None, None, None],
    &[None, Some("ABSTRACT"), Some("ASSERT"), Some("BOOLEAN"), Some("BREAK"), Some("BYTE"), Some("CASE"), Some("CATCH"), Some("CHAR"), Some("CLASS"), Some("CONST"), Some("CONTINUE"), Some("DEFAULT"), Some("DO"), Some("DOUBLE"), Some("ELSE"), Some("ENUM"), Some("EXPORTS"), Some("EXTENDS"), Some("FINAL"), Some("FINALLY"), Some("FLOAT"), Some("FOR"), Some("GOTO"), Some("IF"), Some("IMPLEMENTS"), Some("IMPORT"), Some("INSTANCEOF"), Some("INT"), Some("INTERFACE"), Some("LONG"), Some("MODULE"), Some("NATIVE"), Some("NEW"), Some("NON_SEALED"), Some("OPEN"), Some("OPENS"), Some("PACKAGE"), Some("PERMITS"), Some("PRIVATE"), Some("PROTECTED"), Some("PROVIDES"), Some("PUBLIC"), Some("RECORD"), Some("REQUIRES"), Some("RETURN"), Some("SEALED"), Some("SHORT"), Some("STATIC"), Some("STRICTFP"), Some("SUPER"), Some("SWITCH"), Some("SYNCHRONIZED"), Some("THIS"), Some("THROW"), Some("THROWS"), Some("TO"), Some("TRANSIENT"), Some("TRANSITIVE"), Some("TRY"), Some("USES"), Some("VAR"), Some("VOID"), Some("VOLATILE"), Some("WHEN"), Some("WHILE"), Some("WITH"), Some("YIELD"), Some("DECIMAL_LITERAL"), Some("HEX_LITERAL"), Some("OCT_LITERAL"), Some("BINARY_LITERAL"), Some("FLOAT_LITERAL"), Some("HEX_FLOAT_LITERAL"), Some("BOOL_LITERAL"), Some("CHAR_LITERAL"), Some("STRING_LITERAL"), Some("TEXT_BLOCK"), Some("NULL_LITERAL"), Some("LPAREN"), Some("RPAREN"), Some("LBRACE"), Some("RBRACE"), Some("LBRACK"), Some("RBRACK"), Some("SEMI"), Some("COMMA"), Some("DOT"), Some("ASSIGN"), Some("GT"), Some("LT"), Some("BANG"), Some("TILDE"), Some("QUESTION"), Some("COLON"), Some("EQUAL"), Some("LE"), Some("GE"), Some("NOTEQUAL"), Some("AND"), Some("OR"), Some("INC"), Some("DEC"), Some("ADD"), Some("SUB"), Some("MUL"), Some("DIV"), Some("BITAND"), Some("BITOR"), Some("CARET"), Some("MOD"), Some("ADD_ASSIGN"), Some("SUB_ASSIGN"), Some("MUL_ASSIGN"), Some("DIV_ASSIGN"), Some("AND_ASSIGN"), Some("OR_ASSIGN"), Some("XOR_ASSIGN"), Some("MOD_ASSIGN"), Some("LSHIFT_ASSIGN"), Some("RSHIFT_ASSIGN"), Some("URSHIFT_ASSIGN"), Some("ARROW"), Some("COLONCOLON"), Some("AT"), Some("ELLIPSIS"), Some("WS"), Some("COMMENT"), Some("LINE_COMMENT"), Some("IDENTIFIER")],
    &[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::Hook(antlr4_runtime::semir::HookId::new(0)));
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 58, pred_index: 0, expr: __expr, failure_message: None });
        let __expr = ir.expr(antlr4_runtime::semir::PExpr::Hook(antlr4_runtime::semir::HookId::new(0)));
        predicates.push(antlr4_runtime::ParserSemanticPredicate { rule_index: 75, pred_index: 1, expr: __expr, failure_message: None });

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

pub trait JavaParserHooks: Sized {
    fn do_last_record_component<L>(&mut self, ctx: &mut antlr4_runtime::ParserSemCtx<'_, L>) -> bool
    where
        L: TokenSource;

    fn is_not_identifier_assign<L>(&mut self, ctx: &mut antlr4_runtime::ParserSemCtx<'_, L>) -> bool
    where
        L: TokenSource;

    /// Handles a committed parser action routed to the typed hook. Return
    /// `true` when the action is handled so it satisfies a `hook`/`error`
    /// unknown-semantic policy; the default no-op returns `false` (unhandled),
    /// which fails loud under those policies.
    fn custom_action<L>(&mut self, _ctx: &mut antlr4_runtime::ParserSemCtx<'_, L>, _action: antlr4_runtime::ParserAction) -> bool
    where
        L: TokenSource,
    {
        false
    }
}

#[derive(Clone, Copy, Debug, Default)]
pub struct JavaParserTypedHooks<T>(pub T);

impl<T> JavaParserTypedHooks<T> {
    pub const fn new(inner: T) -> Self { Self(inner) }
}

impl<T> antlr4_runtime::SemanticHooks for JavaParserTypedHooks<T>
where
    T: JavaParserHooks,
{
    fn sempred<L>(&mut self, ctx: &mut antlr4_runtime::ParserSemCtx<'_, L>, rule_index: usize, pred_index: usize) -> Option<bool>
    where
        L: TokenSource,
    {
        match (rule_index, pred_index) {
            (58, 0) => Some(self.0.is_not_identifier_assign(ctx)),
            (75, 1) => Some(self.0.do_last_record_component(ctx)),
            _ => None,
        }
    }

    fn action<L>(&mut self, ctx: &mut antlr4_runtime::ParserSemCtx<'_, L>, action: antlr4_runtime::ParserAction) -> bool
    where
        L: TokenSource,
    {
        self.0.custom_action(ctx, action)
    }
}



#[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 JavaValidatedTree {
    parsed: antlr4_runtime::ParsedFile,
}

impl JavaValidatedTree {
    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 [`JavaValidatedTree`].
#[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 JavaValidationError {
    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 JavaValidationError {
    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 JavaValidationError {
    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 JavaValidationError {
    fn from(error: antlr4_runtime::AntlrError) -> Self {
        Self::Recognition(error)
    }
}

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

#[allow(dead_code)]
fn __context_kind(context: RuleNodeView<'_>) -> usize {
    match context.rule_index() {
        0 => {
            0
        },
        1 => {
            1
        },
        2 => {
            2
        },
        3 => {
            3
        },
        4 => {
            4
        },
        5 => {
            5
        },
        6 => {
            6
        },
        7 => {
            7
        },
        8 => {
            8
        },
        9 => {
            9
        },
        10 => {
            10
        },
        11 => {
            11
        },
        12 => {
            12
        },
        13 => {
            13
        },
        14 => {
            14
        },
        15 => {
            15
        },
        16 => {
            16
        },
        17 => {
            17
        },
        18 => {
            18
        },
        19 => {
            19
        },
        20 => {
            20
        },
        21 => {
            21
        },
        22 => {
            22
        },
        23 => {
            23
        },
        24 => {
            24
        },
        25 => {
            25
        },
        26 => {
            26
        },
        27 => {
            27
        },
        28 => {
            28
        },
        29 => {
            29
        },
        30 => {
            30
        },
        31 => {
            31
        },
        32 => {
            32
        },
        33 => {
            33
        },
        34 => {
            34
        },
        35 => {
            35
        },
        36 => {
            36
        },
        37 => {
            37
        },
        38 => {
            38
        },
        39 => {
            39
        },
        40 => {
            40
        },
        41 => {
            41
        },
        42 => {
            42
        },
        43 => {
            43
        },
        44 => {
            44
        },
        45 => {
            45
        },
        46 => {
            46
        },
        47 => {
            47
        },
        48 => {
            48
        },
        49 => {
            49
        },
        50 => {
            50
        },
        51 => {
            51
        },
        52 => {
            52
        },
        53 => {
            53
        },
        54 => {
            54
        },
        55 => {
            55
        },
        56 => {
            56
        },
        57 => {
            57
        },
        58 => {
            58
        },
        59 => {
            59
        },
        60 => {
            60
        },
        61 => {
            61
        },
        62 => {
            62
        },
        63 => {
            63
        },
        64 => {
            64
        },
        65 => {
            65
        },
        66 => {
            66
        },
        67 => {
            67
        },
        68 => {
            68
        },
        69 => {
            69
        },
        70 => {
            70
        },
        71 => {
            71
        },
        72 => {
            72
        },
        73 => {
            73
        },
        74 => {
            74
        },
        75 => {
            75
        },
        76 => {
            76
        },
        77 => {
            77
        },
        78 => {
            78
        },
        79 => {
            79
        },
        80 => {
            80
        },
        81 => {
            81
        },
        82 => {
            82
        },
        83 => {
            83
        },
        84 => {
            84
        },
        85 => {
            85
        },
        86 => {
            86
        },
        87 => {
            87
        },
        88 => {
            88
        },
        89 => {
            89
        },
        90 => {
            90
        },
        91 => {
            91
        },
        92 => {
            92
        },
        93 => {
            93
        },
        94 => {
            94
        },
        95 => {
            95
        },
        96 => {
            96
        },
        97 => {
            97
        },
        98 => {
            let operator = context.children().next().and_then(antlr4_runtime::Node::as_rule).is_some_and(|child| child.rule_index() == 98);
            if operator {
                match context.context_alt_number() {
                    1 => 100,
                    2 => 101,
                    3 => 103,
                    4 => 105,
                    5 => 109,
                    6 => 109,
                    7 => 109,
                    8 => 109,
                    9 => 110,
                    10 => 109,
                    11 => 109,
                    12 => 109,
                    13 => 109,
                    14 => 109,
                    15 => 109,
                    16 => 111,
                    17 => 109,
                    _ => 98,
                }
            } else {
                match context.context_alt_number() {
                    1 => 99,
                    2 => 102,
                    3 => 103,
                    4 => 103,
                    5 => 104,
                    6 => 106,
                    7 => 107,
                    8 => 108,
                    9 => 112,
                    _ => 98,
                }
            }
        },
        99 => {
            113
        },
        100 => {
            114
        },
        101 => {
            115
        },
        102 => {
            116
        },
        103 => {
            117
        },
        104 => {
            118
        },
        105 => {
            119
        },
        106 => {
            120
        },
        107 => {
            121
        },
        108 => {
            122
        },
        109 => {
            123
        },
        110 => {
            124
        },
        111 => {
            125
        },
        112 => {
            126
        },
        113 => {
            127
        },
        114 => {
            128
        },
        115 => {
            129
        },
        116 => {
            130
        },
        117 => {
            131
        },
        118 => {
            132
        },
        119 => {
            133
        },
        120 => {
            134
        },
        121 => {
            135
        },
        122 => {
            136
        },
        123 => {
            137
        },
        124 => {
            138
        },
        125 => {
            139
        },
        126 => {
            140
        },
        127 => {
            141
        },
        _ => usize::MAX,
    }
}

#[allow(dead_code)]
fn __active_context_kind(
    context: &antlr4_runtime::ParserRuleContext,
    storage: &antlr4_runtime::ParseTreeStorage,
    tokens: &antlr4_runtime::TokenStore,
) -> usize {
    match context.rule_index() {
        0 => {
            0
        },
        1 => {
            1
        },
        2 => {
            2
        },
        3 => {
            3
        },
        4 => {
            4
        },
        5 => {
            5
        },
        6 => {
            6
        },
        7 => {
            7
        },
        8 => {
            8
        },
        9 => {
            9
        },
        10 => {
            10
        },
        11 => {
            11
        },
        12 => {
            12
        },
        13 => {
            13
        },
        14 => {
            14
        },
        15 => {
            15
        },
        16 => {
            16
        },
        17 => {
            17
        },
        18 => {
            18
        },
        19 => {
            19
        },
        20 => {
            20
        },
        21 => {
            21
        },
        22 => {
            22
        },
        23 => {
            23
        },
        24 => {
            24
        },
        25 => {
            25
        },
        26 => {
            26
        },
        27 => {
            27
        },
        28 => {
            28
        },
        29 => {
            29
        },
        30 => {
            30
        },
        31 => {
            31
        },
        32 => {
            32
        },
        33 => {
            33
        },
        34 => {
            34
        },
        35 => {
            35
        },
        36 => {
            36
        },
        37 => {
            37
        },
        38 => {
            38
        },
        39 => {
            39
        },
        40 => {
            40
        },
        41 => {
            41
        },
        42 => {
            42
        },
        43 => {
            43
        },
        44 => {
            44
        },
        45 => {
            45
        },
        46 => {
            46
        },
        47 => {
            47
        },
        48 => {
            48
        },
        49 => {
            49
        },
        50 => {
            50
        },
        51 => {
            51
        },
        52 => {
            52
        },
        53 => {
            53
        },
        54 => {
            54
        },
        55 => {
            55
        },
        56 => {
            56
        },
        57 => {
            57
        },
        58 => {
            58
        },
        59 => {
            59
        },
        60 => {
            60
        },
        61 => {
            61
        },
        62 => {
            62
        },
        63 => {
            63
        },
        64 => {
            64
        },
        65 => {
            65
        },
        66 => {
            66
        },
        67 => {
            67
        },
        68 => {
            68
        },
        69 => {
            69
        },
        70 => {
            70
        },
        71 => {
            71
        },
        72 => {
            72
        },
        73 => {
            73
        },
        74 => {
            74
        },
        75 => {
            75
        },
        76 => {
            76
        },
        77 => {
            77
        },
        78 => {
            78
        },
        79 => {
            79
        },
        80 => {
            80
        },
        81 => {
            81
        },
        82 => {
            82
        },
        83 => {
            83
        },
        84 => {
            84
        },
        85 => {
            85
        },
        86 => {
            86
        },
        87 => {
            87
        },
        88 => {
            88
        },
        89 => {
            89
        },
        90 => {
            90
        },
        91 => {
            91
        },
        92 => {
            92
        },
        93 => {
            93
        },
        94 => {
            94
        },
        95 => {
            95
        },
        96 => {
            96
        },
        97 => {
            97
        },
        98 => {
            let operator = context.child_nodes(storage, tokens).next().and_then(antlr4_runtime::Node::as_rule).is_some_and(|child| child.rule_index() == 98);
            if operator {
                match context.context_alt_number() {
                    1 => 100,
                    2 => 101,
                    3 => 103,
                    4 => 105,
                    5 => 109,
                    6 => 109,
                    7 => 109,
                    8 => 109,
                    9 => 110,
                    10 => 109,
                    11 => 109,
                    12 => 109,
                    13 => 109,
                    14 => 109,
                    15 => 109,
                    16 => 111,
                    17 => 109,
                    _ => 98,
                }
            } else {
                match context.context_alt_number() {
                    1 => 99,
                    2 => 102,
                    3 => 103,
                    4 => 103,
                    5 => 104,
                    6 => 106,
                    7 => 107,
                    8 => 108,
                    9 => 112,
                    _ => 98,
                }
            }
        },
        99 => {
            113
        },
        100 => {
            114
        },
        101 => {
            115
        },
        102 => {
            116
        },
        103 => {
            117
        },
        104 => {
            118
        },
        105 => {
            119
        },
        106 => {
            120
        },
        107 => {
            121
        },
        108 => {
            122
        },
        109 => {
            123
        },
        110 => {
            124
        },
        111 => {
            125
        },
        112 => {
            126
        },
        113 => {
            127
        },
        114 => {
            128
        },
        115 => {
            129
        },
        116 => {
            130
        },
        117 => {
            131
        },
        118 => {
            132
        },
        119 => {
            133
        },
        120 => {
            134
        },
        121 => {
            135
        },
        122 => {
            136
        },
        123 => {
            137
        },
        124 => {
            138
        },
        125 => {
            139
        },
        126 => {
            140
        },
        127 => {
            141
        },
        _ => usize::MAX,
    }
}

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 modular_compulation_unit(&self) -> Option<ModularCompulationUnitContext<'a>> {
        __rule_children(self.__node, 1)
            .next()
            .map(|node| ModularCompulationUnitContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn package_declaration(&self) -> Option<PackageDeclarationContext<'a>> {
        __rule_children(self.__node, 2)
            .next()
            .map(|node| PackageDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn import_declaration_children(&self) -> impl Iterator<Item = ImportDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 3)
            .map(move |node| ImportDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_declaration_children(&self) -> impl Iterator<Item = TypeDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 4)
            .map(move |node| TypeDeclarationContext::__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"))
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CompilationUnitContext<'a, ValidatedTreeContext> {
    pub fn modular_compulation_unit(&self) -> Option<ModularCompulationUnitContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 1)
            .next()
            .map(|node| ModularCompulationUnitContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn package_declaration(&self) -> Option<PackageDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 2)
            .next()
            .map(|node| PackageDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn import_declaration_children(&self) -> impl Iterator<Item = ImportDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 3)
            .map(move |node| ImportDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_declaration_children(&self) -> impl Iterator<Item = TypeDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 4)
            .map(move |node| TypeDeclarationContext::<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)
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ModularCompulationUnitContext {
        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> ModularCompulationUnitContext<'a, State> {
    pub fn import_declaration_children(&self) -> impl Iterator<Item = ImportDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 3)
            .map(move |node| ImportDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_declaration(&self) -> Result<ModuleDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 70)
            .next()
            .map(|node| ModuleDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ModularCompulationUnitContext", "moduleDeclaration"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ModularCompulationUnitContext<'a, ValidatedTreeContext> {
    pub fn import_declaration_children(&self) -> impl Iterator<Item = ImportDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 3)
            .map(move |node| ImportDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_declaration(&self) -> ModuleDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 70).next() else {
            unreachable!("validated ModularCompulationUnitContext is missing required child moduleDeclaration")
        };
        ModuleDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PackageDeclarationContext {
        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> PackageDeclarationContext<'a, State> {
    pub fn qualified_name(&self) -> Result<QualifiedNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PackageDeclarationContext", "qualifiedName"))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn package_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 37)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PackageDeclarationContext", "PACKAGE"))
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PackageDeclarationContext", "SEMI"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PackageDeclarationContext<'a, ValidatedTreeContext> {
    pub fn qualified_name(&self) -> QualifiedNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 52).next() else {
            unreachable!("validated PackageDeclarationContext is missing required child qualifiedName")
        };
        QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn package_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 37).next() else {
            unreachable!("validated PackageDeclarationContext is missing required child PACKAGE")
        };
        TerminalNode::new(node)
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated PackageDeclarationContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ImportDeclarationContext {
        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> ImportDeclarationContext<'a, State> {
    pub fn qualified_name(&self) -> Result<QualifiedNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ImportDeclarationContext", "qualifiedName"))
    }
    pub fn import_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 26)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImportDeclarationContext", "IMPORT"))
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ImportDeclarationContext", "SEMI"))
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ImportDeclarationContext<'a, ValidatedTreeContext> {
    pub fn qualified_name(&self) -> QualifiedNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 52).next() else {
            unreachable!("validated ImportDeclarationContext is missing required child qualifiedName")
        };
        QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn import_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 26).next() else {
            unreachable!("validated ImportDeclarationContext is missing required child IMPORT")
        };
        TerminalNode::new(node)
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated ImportDeclarationContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeDeclarationContext {
        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> TypeDeclarationContext<'a, State> {
    pub fn class_or_interface_modifier_children(&self) -> impl Iterator<Item = ClassOrInterfaceModifierContext<'a>> + '_ {
        __rule_children(self.__node, 6)
            .map(move |node| ClassOrInterfaceModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeDeclarationContext<'a, ValidatedTreeContext> {
    pub fn class_or_interface_modifier_children(&self) -> impl Iterator<Item = ClassOrInterfaceModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 6)
            .map(move |node| ClassOrInterfaceModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ModifierContext {
        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> ModifierContext<'a, State> {
    pub fn class_or_interface_modifier(&self) -> Option<ClassOrInterfaceModifierContext<'a>> {
        __rule_children(self.__node, 6)
            .next()
            .map(|node| ClassOrInterfaceModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn native_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn synchronized_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transient_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn volatile_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 63)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ModifierContext<'a, ValidatedTreeContext> {
    pub fn class_or_interface_modifier(&self) -> Option<ClassOrInterfaceModifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 6)
            .next()
            .map(|node| ClassOrInterfaceModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn native_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 32)
            .next()
            .map(TerminalNode::new)
    }
    pub fn synchronized_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transient_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 57)
            .next()
            .map(TerminalNode::new)
    }
    pub fn volatile_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 63)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassOrInterfaceModifierContext {
        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> ClassOrInterfaceModifierContext<'a, State> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 1)
            .next()
            .map(TerminalNode::new)
    }
    pub fn final_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn non_sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn private_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn protected_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn strictfp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassOrInterfaceModifierContext<'a, ValidatedTreeContext> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 1)
            .next()
            .map(TerminalNode::new)
    }
    pub fn final_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
    pub fn non_sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 34)
            .next()
            .map(TerminalNode::new)
    }
    pub fn private_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 39)
            .next()
            .map(TerminalNode::new)
    }
    pub fn protected_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 40)
            .next()
            .map(TerminalNode::new)
    }
    pub fn public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn strictfp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableModifierContext {
        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> VariableModifierContext<'a, State> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn final_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableModifierContext<'a, ValidatedTreeContext> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn final_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 19)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassDeclarationContext {
        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> ClassDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_body(&self) -> Result<ClassBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| ClassBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ClassDeclarationContext", "classBody"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ClassDeclarationContext", "identifier"))
    }
    pub fn type_list_children(&self) -> impl Iterator<Item = TypeListContext<'a>> + '_ {
        __rule_children(self.__node, 121)
            .map(move |node| TypeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ClassDeclarationContext", "CLASS"))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_body(&self) -> ClassBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 17).next() else {
            unreachable!("validated ClassDeclarationContext is missing required child classBody")
        };
        ClassBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated ClassDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_list_children(&self) -> impl Iterator<Item = TypeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 121)
            .map(move |node| TypeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 9).next() else {
            unreachable!("validated ClassDeclarationContext is missing required child CLASS")
        };
        TerminalNode::new(node)
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParametersContext {
        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> TypeParametersContext<'a, State> {
    pub fn type_parameter_children(&self) -> impl Iterator<Item = TypeParameterContext<'a>> + '_ {
        __rule_children(self.__node, 10)
            .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, 86).map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParametersContext", "GT"))
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeParametersContext", "LT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParametersContext<'a, ValidatedTreeContext> {
    pub fn type_parameter_children(&self) -> impl Iterator<Item = TypeParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 10)
            .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, 86).map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 89).next() else {
            unreachable!("validated TypeParametersContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 90).next() else {
            unreachable!("validated TypeParametersContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeParameterContext {
        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> TypeParameterContext<'a, State> {
    pub fn type_bound(&self) -> Option<TypeBoundContext<'a>> {
        __rule_children(self.__node, 11)
            .next()
            .map(|node| TypeBoundContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("TypeParameterContext", "identifier"))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeParameterContext<'a, ValidatedTreeContext> {
    pub fn type_bound(&self) -> Option<TypeBoundContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 11)
            .next()
            .map(|node| TypeBoundContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated TypeParameterContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeBoundContext {
        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> TypeBoundContext<'a, State> {
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeBoundContext<'a, ValidatedTreeContext> {
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumDeclarationContext {
        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> EnumDeclarationContext<'a, State> {
    pub fn enum_constants(&self) -> Option<EnumConstantsContext<'a>> {
        __rule_children(self.__node, 13)
            .next()
            .map(|node| EnumConstantsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_body_declarations(&self) -> Option<EnumBodyDeclarationsContext<'a>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| EnumBodyDeclarationsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "identifier"))
    }
    pub fn type_list(&self) -> Option<TypeListContext<'a>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| TypeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 16)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "ENUM"))
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnumDeclarationContext", "RBRACE"))
    }
    pub fn comma_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 86)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumDeclarationContext<'a, ValidatedTreeContext> {
    pub fn enum_constants(&self) -> Option<EnumConstantsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 13)
            .next()
            .map(|node| EnumConstantsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_body_declarations(&self) -> Option<EnumBodyDeclarationsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 15)
            .next()
            .map(|node| EnumBodyDeclarationsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_list(&self) -> Option<TypeListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| TypeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 16).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child ENUM")
        };
        TerminalNode::new(node)
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 81).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated EnumDeclarationContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn comma_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 86)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumConstantsContext {
        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> EnumConstantsContext<'a, State> {
    pub fn enum_constant_children(&self) -> impl Iterator<Item = EnumConstantContext<'a>> + '_ {
        __rule_children(self.__node, 14)
            .map(move |node| EnumConstantContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumConstantsContext<'a, ValidatedTreeContext> {
    pub fn enum_constant_children(&self) -> impl Iterator<Item = EnumConstantContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 14)
            .map(move |node| EnumConstantContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumConstantContext {
        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> EnumConstantContext<'a, State> {
    pub fn class_body(&self) -> Option<ClassBodyContext<'a>> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| ClassBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnumConstantContext", "identifier"))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumConstantContext<'a, ValidatedTreeContext> {
    pub fn class_body(&self) -> Option<ClassBodyContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| ClassBodyContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated EnumConstantContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnumBodyDeclarationsContext {
        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> EnumBodyDeclarationsContext<'a, State> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnumBodyDeclarationsContext", "SEMI"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnumBodyDeclarationsContext<'a, ValidatedTreeContext> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated EnumBodyDeclarationsContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceDeclarationContext {
        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> InterfaceDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_body(&self) -> Result<InterfaceBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 18)
            .next()
            .map(|node| InterfaceBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceDeclarationContext", "interfaceBody"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceDeclarationContext", "identifier"))
    }
    pub fn type_list_children(&self) -> impl Iterator<Item = TypeListContext<'a>> + '_ {
        __rule_children(self.__node, 121)
            .map(move |node| TypeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interface_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterfaceDeclarationContext", "INTERFACE"))
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_body(&self) -> InterfaceBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 18).next() else {
            unreachable!("validated InterfaceDeclarationContext is missing required child interfaceBody")
        };
        InterfaceBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated InterfaceDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_list_children(&self) -> impl Iterator<Item = TypeListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 121)
            .map(move |node| TypeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn interface_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 29).next() else {
            unreachable!("validated InterfaceDeclarationContext is missing required child INTERFACE")
        };
        TerminalNode::new(node)
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassBodyContext {
        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> ClassBodyContext<'a, State> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ClassBodyContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ClassBodyContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassBodyContext<'a, ValidatedTreeContext> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::<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, 81).next() else {
            unreachable!("validated ClassBodyContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated ClassBodyContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceBodyContext {
        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> InterfaceBodyContext<'a, State> {
    pub fn interface_body_declaration_children(&self) -> impl Iterator<Item = InterfaceBodyDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| InterfaceBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterfaceBodyContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InterfaceBodyContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceBodyContext<'a, ValidatedTreeContext> {
    pub fn interface_body_declaration_children(&self) -> impl Iterator<Item = InterfaceBodyDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 29)
            .map(move |node| InterfaceBodyDeclarationContext::<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, 81).next() else {
            unreachable!("validated InterfaceBodyContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated InterfaceBodyContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassBodyDeclarationContext {
        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> ClassBodyDeclarationContext<'a, State> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration(&self) -> Option<MemberDeclarationContext<'a>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| MemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassBodyDeclarationContext<'a, ValidatedTreeContext> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn member_declaration(&self) -> Option<MemberDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 20)
            .next()
            .map(|node| MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MemberDeclarationContext {
        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> MemberDeclarationContext<'a, State> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_declaration(&self) -> Option<MethodDeclarationContext<'a>> {
        __rule_children(self.__node, 21)
            .next()
            .map(|node| MethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_method_declaration(&self) -> Option<GenericMethodDeclarationContext<'a>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| GenericMethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_constructor_declaration(&self) -> Option<GenericConstructorDeclarationContext<'a>> {
        __rule_children(self.__node, 25)
            .next()
            .map(|node| GenericConstructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constructor_declaration(&self) -> Option<ConstructorDeclarationContext<'a>> {
        __rule_children(self.__node, 26)
            .next()
            .map(|node| ConstructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_declaration(&self) -> Option<FieldDeclarationContext<'a>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| FieldDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MemberDeclarationContext<'a, ValidatedTreeContext> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_declaration(&self) -> Option<MethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 21)
            .next()
            .map(|node| MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_method_declaration(&self) -> Option<GenericMethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 24)
            .next()
            .map(|node| GenericMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_constructor_declaration(&self) -> Option<GenericConstructorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 25)
            .next()
            .map(|node| GenericConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn constructor_declaration(&self) -> Option<ConstructorDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 26)
            .next()
            .map(|node| ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn field_declaration(&self) -> Option<FieldDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 28)
            .next()
            .map(|node| FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodDeclarationContext {
        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> MethodDeclarationContext<'a, State> {
    pub fn method_body(&self) -> Result<MethodBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| MethodBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "methodBody"))
    }
    pub fn type_type_or_void(&self) -> Result<TypeTypeOrVoidContext<'a>, MissingChildError> {
        __rule_children(self.__node, 23)
            .next()
            .map(|node| TypeTypeOrVoidContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "typeTypeOrVoid"))
    }
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> Result<FormalParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 46)
            .next()
            .map(|node| FormalParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "formalParameters"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodDeclarationContext", "identifier"))
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn method_body(&self) -> MethodBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 22).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child methodBody")
        };
        MethodBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type_or_void(&self) -> TypeTypeOrVoidContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 23).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child typeTypeOrVoid")
        };
        TypeTypeOrVoidContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> FormalParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 46).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child formalParameters")
        };
        FormalParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated MethodDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodBodyContext {
        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> MethodBodyContext<'a, State> {
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MethodBodyContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeTypeOrVoidContext {
        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> TypeTypeOrVoidContext<'a, State> {
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeTypeOrVoidContext<'a, ValidatedTreeContext> {
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn void_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 62)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GenericMethodDeclarationContext {
        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> GenericMethodDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Result<TypeParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericMethodDeclarationContext", "typeParameters"))
    }
    pub fn method_declaration(&self) -> Result<MethodDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 21)
            .next()
            .map(|node| MethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericMethodDeclarationContext", "methodDeclaration"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GenericMethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> TypeParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 9).next() else {
            unreachable!("validated GenericMethodDeclarationContext is missing required child typeParameters")
        };
        TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn method_declaration(&self) -> MethodDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 21).next() else {
            unreachable!("validated GenericMethodDeclarationContext is missing required child methodDeclaration")
        };
        MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GenericConstructorDeclarationContext {
        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> GenericConstructorDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Result<TypeParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericConstructorDeclarationContext", "typeParameters"))
    }
    pub fn constructor_declaration(&self) -> Result<ConstructorDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 26)
            .next()
            .map(|node| ConstructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericConstructorDeclarationContext", "constructorDeclaration"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GenericConstructorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> TypeParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 9).next() else {
            unreachable!("validated GenericConstructorDeclarationContext is missing required child typeParameters")
        };
        TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn constructor_declaration(&self) -> ConstructorDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 26).next() else {
            unreachable!("validated GenericConstructorDeclarationContext is missing required child constructorDeclaration")
        };
        ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstructorDeclarationContext {
        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> ConstructorDeclarationContext<'a, State> {
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> Result<FormalParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 46)
            .next()
            .map(|node| FormalParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "formalParameters"))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "block"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "identifier"))
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn constructor_body(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .nth(0)
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstructorDeclarationContext", "constructorBody"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstructorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> FormalParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 46).next() else {
            unreachable!("validated ConstructorDeclarationContext is missing required child formalParameters")
        };
        FormalParametersContext::<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, 78).next() else {
            unreachable!("validated ConstructorDeclarationContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated ConstructorDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn constructor_body(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 78)
            .nth(0)
        else {
            unreachable!("validated ConstructorDeclarationContext is missing required child constructorBody")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CompactConstructorDeclarationContext {
        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> CompactConstructorDeclarationContext<'a, State> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CompactConstructorDeclarationContext", "block"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CompactConstructorDeclarationContext", "identifier"))
    }
    pub fn constructor_body(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .nth(0)
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CompactConstructorDeclarationContext", "constructorBody"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CompactConstructorDeclarationContext<'a, ValidatedTreeContext> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::<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, 78).next() else {
            unreachable!("validated CompactConstructorDeclarationContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated CompactConstructorDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn constructor_body(&self) -> BlockContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 78)
            .nth(0)
        else {
            unreachable!("validated CompactConstructorDeclarationContext is missing required child constructorBody")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FieldDeclarationContext {
        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> FieldDeclarationContext<'a, State> {
    pub fn variable_declarators(&self) -> Result<VariableDeclaratorsContext<'a>, MissingChildError> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FieldDeclarationContext", "variableDeclarators"))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FieldDeclarationContext", "typeType"))
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FieldDeclarationContext", "SEMI"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FieldDeclarationContext<'a, ValidatedTreeContext> {
    pub fn variable_declarators(&self) -> VariableDeclaratorsContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 37).next() else {
            unreachable!("validated FieldDeclarationContext is missing required child variableDeclarators")
        };
        VariableDeclaratorsContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated FieldDeclarationContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated FieldDeclarationContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceBodyDeclarationContext {
        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> InterfaceBodyDeclarationContext<'a, State> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_member_declaration(&self) -> Option<InterfaceMemberDeclarationContext<'a>> {
        __rule_children(self.__node, 30)
            .next()
            .map(|node| InterfaceMemberDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceBodyDeclarationContext<'a, ValidatedTreeContext> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_member_declaration(&self) -> Option<InterfaceMemberDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 30)
            .next()
            .map(|node| InterfaceMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceMemberDeclarationContext {
        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> InterfaceMemberDeclarationContext<'a, State> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn const_declaration(&self) -> Option<ConstDeclarationContext<'a>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ConstDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_method_declaration(&self) -> Option<InterfaceMethodDeclarationContext<'a>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| InterfaceMethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_interface_method_declaration(&self) -> Option<GenericInterfaceMethodDeclarationContext<'a>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| GenericInterfaceMethodDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceMemberDeclarationContext<'a, ValidatedTreeContext> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn const_declaration(&self) -> Option<ConstDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 31)
            .next()
            .map(|node| ConstDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_method_declaration(&self) -> Option<InterfaceMethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 33)
            .next()
            .map(|node| InterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn generic_interface_method_declaration(&self) -> Option<GenericInterfaceMethodDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 35)
            .next()
            .map(|node| GenericInterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstDeclarationContext {
        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> ConstDeclarationContext<'a, State> {
    pub fn constant_declarator_children(&self) -> impl Iterator<Item = ConstantDeclaratorContext<'a>> + '_ {
        __rule_children(self.__node, 32)
            .map(move |node| ConstantDeclaratorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstDeclarationContext", "typeType"))
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstDeclarationContext", "SEMI"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstDeclarationContext<'a, ValidatedTreeContext> {
    pub fn constant_declarator_children(&self) -> impl Iterator<Item = ConstantDeclaratorContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 32)
            .map(move |node| ConstantDeclaratorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated ConstDeclarationContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated ConstDeclarationContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ConstantDeclaratorContext {
        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> ConstantDeclaratorContext<'a, State> {
    pub fn variable_initializer(&self) -> Result<VariableInitializerContext<'a>, MissingChildError> {
        __rule_children(self.__node, 40)
            .next()
            .map(|node| VariableInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstantDeclaratorContext", "variableInitializer"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ConstantDeclaratorContext", "identifier"))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ConstantDeclaratorContext", "ASSIGN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ConstantDeclaratorContext<'a, ValidatedTreeContext> {
    pub fn variable_initializer(&self) -> VariableInitializerContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 40).next() else {
            unreachable!("validated ConstantDeclaratorContext is missing required child variableInitializer")
        };
        VariableInitializerContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated ConstantDeclaratorContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 88).next() else {
            unreachable!("validated ConstantDeclaratorContext is missing required child ASSIGN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceMethodDeclarationContext {
        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> InterfaceMethodDeclarationContext<'a, State> {
    pub fn interface_method_modifier_children(&self) -> impl Iterator<Item = InterfaceMethodModifierContext<'a>> + '_ {
        __rule_children(self.__node, 34)
            .map(move |node| InterfaceMethodModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_common_body_declaration(&self) -> Result<InterfaceCommonBodyDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 36)
            .next()
            .map(|node| InterfaceCommonBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceMethodDeclarationContext", "interfaceCommonBodyDeclaration"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceMethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn interface_method_modifier_children(&self) -> impl Iterator<Item = InterfaceMethodModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 34)
            .map(move |node| InterfaceMethodModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_common_body_declaration(&self) -> InterfaceCommonBodyDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 36).next() else {
            unreachable!("validated InterfaceMethodDeclarationContext is missing required child interfaceCommonBodyDeclaration")
        };
        InterfaceCommonBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceMethodModifierContext {
        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> InterfaceMethodModifierContext<'a, State> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 1)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn strictfp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceMethodModifierContext<'a, ValidatedTreeContext> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn abstract_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 1)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn public_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 42)
            .next()
            .map(TerminalNode::new)
    }
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn strictfp_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 49)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GenericInterfaceMethodDeclarationContext {
        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> GenericInterfaceMethodDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Result<TypeParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericInterfaceMethodDeclarationContext", "typeParameters"))
    }
    pub fn interface_method_modifier_children(&self) -> impl Iterator<Item = InterfaceMethodModifierContext<'a>> + '_ {
        __rule_children(self.__node, 34)
            .map(move |node| InterfaceMethodModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_common_body_declaration(&self) -> Result<InterfaceCommonBodyDeclarationContext<'a>, MissingChildError> {
        __rule_children(self.__node, 36)
            .next()
            .map(|node| InterfaceCommonBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GenericInterfaceMethodDeclarationContext", "interfaceCommonBodyDeclaration"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> GenericInterfaceMethodDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> TypeParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 9).next() else {
            unreachable!("validated GenericInterfaceMethodDeclarationContext is missing required child typeParameters")
        };
        TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn interface_method_modifier_children(&self) -> impl Iterator<Item = InterfaceMethodModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 34)
            .map(move |node| InterfaceMethodModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_common_body_declaration(&self) -> InterfaceCommonBodyDeclarationContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 36).next() else {
            unreachable!("validated GenericInterfaceMethodDeclarationContext is missing required child interfaceCommonBodyDeclaration")
        };
        InterfaceCommonBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InterfaceCommonBodyDeclarationContext {
        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> InterfaceCommonBodyDeclarationContext<'a, State> {
    pub fn method_body(&self) -> Result<MethodBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 22)
            .next()
            .map(|node| MethodBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceCommonBodyDeclarationContext", "methodBody"))
    }
    pub fn type_type_or_void(&self) -> Result<TypeTypeOrVoidContext<'a>, MissingChildError> {
        __rule_children(self.__node, 23)
            .next()
            .map(|node| TypeTypeOrVoidContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceCommonBodyDeclarationContext", "typeTypeOrVoid"))
    }
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> Result<FormalParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 46)
            .next()
            .map(|node| FormalParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceCommonBodyDeclarationContext", "formalParameters"))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InterfaceCommonBodyDeclarationContext", "identifier"))
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InterfaceCommonBodyDeclarationContext<'a, ValidatedTreeContext> {
    pub fn method_body(&self) -> MethodBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 22).next() else {
            unreachable!("validated InterfaceCommonBodyDeclarationContext is missing required child methodBody")
        };
        MethodBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type_or_void(&self) -> TypeTypeOrVoidContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 23).next() else {
            unreachable!("validated InterfaceCommonBodyDeclarationContext is missing required child typeTypeOrVoid")
        };
        TypeTypeOrVoidContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn qualified_name_list(&self) -> Option<QualifiedNameListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 45)
            .next()
            .map(|node| QualifiedNameListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameters(&self) -> FormalParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 46).next() else {
            unreachable!("validated InterfaceCommonBodyDeclarationContext is missing required child formalParameters")
        };
        FormalParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated InterfaceCommonBodyDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn throws_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 55)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDeclaratorsContext {
        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> VariableDeclaratorsContext<'a, State> {
    pub fn variable_declarator_children(&self) -> impl Iterator<Item = VariableDeclaratorContext<'a>> + '_ {
        __rule_children(self.__node, 38)
            .map(move |node| VariableDeclaratorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDeclaratorsContext<'a, ValidatedTreeContext> {
    pub fn variable_declarator_children(&self) -> impl Iterator<Item = VariableDeclaratorContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 38)
            .map(move |node| VariableDeclaratorContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDeclaratorContext {
        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> VariableDeclaratorContext<'a, State> {
    pub fn variable_declarator_id(&self) -> Result<VariableDeclaratorIdContext<'a>, MissingChildError> {
        __rule_children(self.__node, 39)
            .next()
            .map(|node| VariableDeclaratorIdContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("VariableDeclaratorContext", "variableDeclaratorId"))
    }
    pub fn variable_initializer(&self) -> Option<VariableInitializerContext<'a>> {
        __rule_children(self.__node, 40)
            .next()
            .map(|node| VariableInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDeclaratorContext<'a, ValidatedTreeContext> {
    pub fn variable_declarator_id(&self) -> VariableDeclaratorIdContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 39).next() else {
            unreachable!("validated VariableDeclaratorContext is missing required child variableDeclaratorId")
        };
        VariableDeclaratorIdContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn variable_initializer(&self) -> Option<VariableInitializerContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 40)
            .next()
            .map(|node| VariableInitializerContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableDeclaratorIdContext {
        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> VariableDeclaratorIdContext<'a, State> {
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("VariableDeclaratorIdContext", "identifier"))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableDeclaratorIdContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated VariableDeclaratorIdContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct VariableInitializerContext {
        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> VariableInitializerContext<'a, State> {
    pub fn array_initializer(&self) -> Option<ArrayInitializerContext<'a>> {
        __rule_children(self.__node, 41)
            .next()
            .map(|node| ArrayInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> VariableInitializerContext<'a, ValidatedTreeContext> {
    pub fn array_initializer(&self) -> Option<ArrayInitializerContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 41)
            .next()
            .map(|node| ArrayInitializerContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrayInitializerContext {
        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> ArrayInitializerContext<'a, State> {
    pub fn variable_initializer_children(&self) -> impl Iterator<Item = VariableInitializerContext<'a>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| VariableInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrayInitializerContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArrayInitializerContext", "RBRACE"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrayInitializerContext<'a, ValidatedTreeContext> {
    pub fn variable_initializer_children(&self) -> impl Iterator<Item = VariableInitializerContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 40)
            .map(move |node| VariableInitializerContext::<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, 81).next() else {
            unreachable!("validated ArrayInitializerContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated ArrayInitializerContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassTypeContext {
        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> ClassTypeContext<'a, State> {
    pub fn package_name_children(&self) -> impl Iterator<Item = PackageNameContext<'a>> + '_ {
        __rule_children(self.__node, 43)
            .map(move |node| PackageNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_identifier_children(&self) -> impl Iterator<Item = TypeIdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 82)
            .map(move |node| TypeIdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments_children(&self) -> impl Iterator<Item = TypeArgumentsContext<'a>> + '_ {
        __rule_children(self.__node, 124)
            .map(move |node| TypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ClassTypeContext<'a, ValidatedTreeContext> {
    pub fn package_name_children(&self) -> impl Iterator<Item = PackageNameContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 43)
            .map(move |node| PackageNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_identifier_children(&self) -> impl Iterator<Item = TypeIdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 82)
            .map(move |node| TypeIdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments_children(&self) -> impl Iterator<Item = TypeArgumentsContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 124)
            .map(move |node| TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PackageNameContext {
        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> PackageNameContext<'a, State> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PackageNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeArgumentContext {
        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> TypeArgumentContext<'a, State> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeArgumentContext<'a, ValidatedTreeContext> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn extends_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 18)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QualifiedNameListContext {
        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> QualifiedNameListContext<'a, State> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QualifiedNameListContext<'a, ValidatedTreeContext> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FormalParametersContext {
        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> FormalParametersContext<'a, State> {
    pub fn receiver_parameter(&self) -> Option<ReceiverParameterContext<'a>> {
        __rule_children(self.__node, 47)
            .next()
            .map(|node| ReceiverParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameter_list_children(&self) -> impl Iterator<Item = FormalParameterListContext<'a>> + '_ {
        __rule_children(self.__node, 48)
            .map(move |node| FormalParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameter(&self) -> Option<FormalParameterContext<'a>> {
        __rule_children(self.__node, 49)
            .next()
            .map(|node| FormalParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FormalParametersContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FormalParametersContext", "RPAREN"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FormalParametersContext<'a, ValidatedTreeContext> {
    pub fn receiver_parameter(&self) -> Option<ReceiverParameterContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 47)
            .next()
            .map(|node| ReceiverParameterContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameter_list_children(&self) -> impl Iterator<Item = FormalParameterListContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 48)
            .map(move |node| FormalParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn formal_parameter(&self) -> Option<FormalParameterContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 49)
            .next()
            .map(|node| FormalParameterContext::<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, 79).next() else {
            unreachable!("validated FormalParametersContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated FormalParametersContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ReceiverParameterContext {
        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> ReceiverParameterContext<'a, State> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ReceiverParameterContext", "typeType"))
    }
    pub fn this_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ReceiverParameterContext", "THIS"))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ReceiverParameterContext<'a, ValidatedTreeContext> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated ReceiverParameterContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn this_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 53).next() else {
            unreachable!("validated ReceiverParameterContext is missing required child THIS")
        };
        TerminalNode::new(node)
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FormalParameterListContext {
        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> FormalParameterListContext<'a, State> {
    pub fn formal_parameter_children(&self) -> impl Iterator<Item = FormalParameterContext<'a>> + '_ {
        __rule_children(self.__node, 49)
            .map(move |node| FormalParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FormalParameterListContext<'a, ValidatedTreeContext> {
    pub fn formal_parameter_children(&self) -> impl Iterator<Item = FormalParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 49)
            .map(move |node| FormalParameterContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FormalParameterContext {
        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> FormalParameterContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> Result<VariableDeclaratorIdContext<'a>, MissingChildError> {
        __rule_children(self.__node, 39)
            .next()
            .map(|node| VariableDeclaratorIdContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FormalParameterContext", "variableDeclaratorId"))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FormalParameterContext", "typeType"))
    }
    pub fn ellipsis_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FormalParameterContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> VariableDeclaratorIdContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 39).next() else {
            unreachable!("validated FormalParameterContext is missing required child variableDeclaratorId")
        };
        VariableDeclaratorIdContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated FormalParameterContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn ellipsis_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaLvtiListContext {
        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> LambdaLvtiListContext<'a, State> {
    pub fn lambda_lvti_parameter_children(&self) -> impl Iterator<Item = LambdaLvtiParameterContext<'a>> + '_ {
        __rule_children(self.__node, 51)
            .map(move |node| LambdaLvtiParameterContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaLvtiListContext<'a, ValidatedTreeContext> {
    pub fn lambda_lvti_parameter_children(&self) -> impl Iterator<Item = LambdaLvtiParameterContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 51)
            .map(move |node| LambdaLvtiParameterContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaLvtiParameterContext {
        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> LambdaLvtiParameterContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LambdaLvtiParameterContext", "identifier"))
    }
    pub fn var_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LambdaLvtiParameterContext", "VAR"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaLvtiParameterContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated LambdaLvtiParameterContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn var_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 61).next() else {
            unreachable!("validated LambdaLvtiParameterContext is missing required child VAR")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct QualifiedNameContext {
        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> QualifiedNameContext<'a, State> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> QualifiedNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LiteralContext {
        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> LiteralContext<'a, State> {
    pub fn integer_literal(&self) -> Option<IntegerLiteralContext<'a>> {
        __rule_children(self.__node, 54)
            .next()
            .map(|node| IntegerLiteralContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn float_literal(&self) -> Option<FloatLiteralContext<'a>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| FloatLiteralContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bool_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
    }
    pub fn char_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn string_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn text_block_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn null_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LiteralContext<'a, ValidatedTreeContext> {
    pub fn integer_literal(&self) -> Option<IntegerLiteralContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 54)
            .next()
            .map(|node| IntegerLiteralContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn float_literal(&self) -> Option<FloatLiteralContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 55)
            .next()
            .map(|node| FloatLiteralContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bool_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 74)
            .next()
            .map(TerminalNode::new)
    }
    pub fn char_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 75)
            .next()
            .map(TerminalNode::new)
    }
    pub fn string_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 76)
            .next()
            .map(TerminalNode::new)
    }
    pub fn text_block_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 77)
            .next()
            .map(TerminalNode::new)
    }
    pub fn null_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IntegerLiteralContext {
        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> IntegerLiteralContext<'a, State> {
    pub fn decimal_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hex_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 69)
            .next()
            .map(TerminalNode::new)
    }
    pub fn oct_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn binary_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IntegerLiteralContext<'a, ValidatedTreeContext> {
    pub fn decimal_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 68)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hex_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 69)
            .next()
            .map(TerminalNode::new)
    }
    pub fn oct_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 70)
            .next()
            .map(TerminalNode::new)
    }
    pub fn binary_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 71)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FloatLiteralContext {
        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> FloatLiteralContext<'a, State> {
    pub fn float_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hex_float_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> FloatLiteralContext<'a, ValidatedTreeContext> {
    pub fn float_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 72)
            .next()
            .map(TerminalNode::new)
    }
    pub fn hex_float_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 73)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationContext {
        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> AnnotationContext<'a, State> {
    pub fn qualified_name(&self) -> Result<QualifiedNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationContext", "qualifiedName"))
    }
    pub fn annotation_field_values(&self) -> Option<AnnotationFieldValuesContext<'a>> {
        __rule_children(self.__node, 57)
            .next()
            .map(|node| AnnotationFieldValuesContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn at_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationContext", "AT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationContext<'a, ValidatedTreeContext> {
    pub fn qualified_name(&self) -> QualifiedNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 52).next() else {
            unreachable!("validated AnnotationContext is missing required child qualifiedName")
        };
        QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn annotation_field_values(&self) -> Option<AnnotationFieldValuesContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 57)
            .next()
            .map(|node| AnnotationFieldValuesContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn at_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 124).next() else {
            unreachable!("validated AnnotationContext is missing required child AT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationFieldValuesContext {
        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> AnnotationFieldValuesContext<'a, State> {
    pub fn annotation_field_value_children(&self) -> impl Iterator<Item = AnnotationFieldValueContext<'a>> + '_ {
        __rule_children(self.__node, 58)
            .map(move |node| AnnotationFieldValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationFieldValuesContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationFieldValuesContext", "RPAREN"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationFieldValuesContext<'a, ValidatedTreeContext> {
    pub fn annotation_field_value_children(&self) -> impl Iterator<Item = AnnotationFieldValueContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 58)
            .map(move |node| AnnotationFieldValueContext::<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, 79).next() else {
            unreachable!("validated AnnotationFieldValuesContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated AnnotationFieldValuesContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationFieldValueContext {
        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> AnnotationFieldValueContext<'a, State> {
    pub fn annotation_value(&self) -> Result<AnnotationValueContext<'a>, MissingChildError> {
        __rule_children(self.__node, 59)
            .next()
            .map(|node| AnnotationValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationFieldValueContext", "annotationValue"))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationFieldValueContext<'a, ValidatedTreeContext> {
    pub fn annotation_value(&self) -> AnnotationValueContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 59).next() else {
            unreachable!("validated AnnotationFieldValueContext is missing required child annotationValue")
        };
        AnnotationValueContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationValueContext {
        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> AnnotationValueContext<'a, State> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_value_children(&self) -> impl Iterator<Item = AnnotationValueContext<'a>> + '_ {
        __rule_children(self.__node, 59)
            .map(move |node| AnnotationValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationValueContext<'a, ValidatedTreeContext> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_value_children(&self) -> impl Iterator<Item = AnnotationValueContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 59)
            .map(move |node| AnnotationValueContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ElementValueContext {
        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> ElementValueContext<'a, State> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn element_value_array_initializer(&self) -> Option<ElementValueArrayInitializerContext<'a>> {
        __rule_children(self.__node, 61)
            .next()
            .map(|node| ElementValueArrayInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ElementValueContext<'a, ValidatedTreeContext> {
    pub fn annotation(&self) -> Option<AnnotationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 56)
            .next()
            .map(|node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn element_value_array_initializer(&self) -> Option<ElementValueArrayInitializerContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 61)
            .next()
            .map(|node| ElementValueArrayInitializerContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ElementValueArrayInitializerContext {
        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> ElementValueArrayInitializerContext<'a, State> {
    pub fn element_value_children(&self) -> impl Iterator<Item = ElementValueContext<'a>> + '_ {
        __rule_children(self.__node, 60)
            .map(move |node| ElementValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ElementValueArrayInitializerContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ElementValueArrayInitializerContext", "RBRACE"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ElementValueArrayInitializerContext<'a, ValidatedTreeContext> {
    pub fn element_value_children(&self) -> impl Iterator<Item = ElementValueContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 60)
            .map(move |node| ElementValueContext::<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, 81).next() else {
            unreachable!("validated ElementValueArrayInitializerContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated ElementValueArrayInitializerContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationTypeDeclarationContext {
        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> AnnotationTypeDeclarationContext<'a, State> {
    pub fn annotation_type_body(&self) -> Result<AnnotationTypeBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 63)
            .next()
            .map(|node| AnnotationTypeBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationTypeDeclarationContext", "annotationTypeBody"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationTypeDeclarationContext", "identifier"))
    }
    pub fn interface_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 29)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationTypeDeclarationContext", "INTERFACE"))
    }
    pub fn at_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 124)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationTypeDeclarationContext", "AT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationTypeDeclarationContext<'a, ValidatedTreeContext> {
    pub fn annotation_type_body(&self) -> AnnotationTypeBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 63).next() else {
            unreachable!("validated AnnotationTypeDeclarationContext is missing required child annotationTypeBody")
        };
        AnnotationTypeBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated AnnotationTypeDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn interface_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 29).next() else {
            unreachable!("validated AnnotationTypeDeclarationContext is missing required child INTERFACE")
        };
        TerminalNode::new(node)
    }
    pub fn at_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 124).next() else {
            unreachable!("validated AnnotationTypeDeclarationContext is missing required child AT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationTypeBodyContext {
        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> AnnotationTypeBodyContext<'a, State> {
    pub fn annotation_type_element_declaration_children(&self) -> impl Iterator<Item = AnnotationTypeElementDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 64)
            .map(move |node| AnnotationTypeElementDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationTypeBodyContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationTypeBodyContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationTypeBodyContext<'a, ValidatedTreeContext> {
    pub fn annotation_type_element_declaration_children(&self) -> impl Iterator<Item = AnnotationTypeElementDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 64)
            .map(move |node| AnnotationTypeElementDeclarationContext::<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, 81).next() else {
            unreachable!("validated AnnotationTypeBodyContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated AnnotationTypeBodyContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationTypeElementDeclarationContext {
        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> AnnotationTypeElementDeclarationContext<'a, State> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_element_rest(&self) -> Option<AnnotationTypeElementRestContext<'a>> {
        __rule_children(self.__node, 65)
            .next()
            .map(|node| AnnotationTypeElementRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationTypeElementDeclarationContext<'a, ValidatedTreeContext> {
    pub fn modifier_children(&self) -> impl Iterator<Item = ModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 5)
            .map(move |node| ModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_element_rest(&self) -> Option<AnnotationTypeElementRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 65)
            .next()
            .map(|node| AnnotationTypeElementRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationTypeElementRestContext {
        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> AnnotationTypeElementRestContext<'a, State> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_method_or_constant_rest(&self) -> Option<AnnotationMethodOrConstantRestContext<'a>> {
        __rule_children(self.__node, 66)
            .next()
            .map(|node| AnnotationMethodOrConstantRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationTypeElementRestContext<'a, ValidatedTreeContext> {
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 16)
            .next()
            .map(|node| InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_type_declaration(&self) -> Option<AnnotationTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 62)
            .next()
            .map(|node| AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_method_or_constant_rest(&self) -> Option<AnnotationMethodOrConstantRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 66)
            .next()
            .map(|node| AnnotationMethodOrConstantRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_declaration(&self) -> Option<RecordDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 73)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationMethodOrConstantRestContext {
        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> AnnotationMethodOrConstantRestContext<'a, State> {
    pub fn annotation_method_rest(&self) -> Option<AnnotationMethodRestContext<'a>> {
        __rule_children(self.__node, 67)
            .next()
            .map(|node| AnnotationMethodRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_constant_rest(&self) -> Option<AnnotationConstantRestContext<'a>> {
        __rule_children(self.__node, 68)
            .next()
            .map(|node| AnnotationConstantRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationMethodOrConstantRestContext<'a, ValidatedTreeContext> {
    pub fn annotation_method_rest(&self) -> Option<AnnotationMethodRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 67)
            .next()
            .map(|node| AnnotationMethodRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_constant_rest(&self) -> Option<AnnotationConstantRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 68)
            .next()
            .map(|node| AnnotationConstantRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationMethodRestContext {
        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> AnnotationMethodRestContext<'a, State> {
    pub fn default_value(&self) -> Option<DefaultValueContext<'a>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| DefaultValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationMethodRestContext", "identifier"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationMethodRestContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("AnnotationMethodRestContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> AnnotationMethodRestContext<'a, ValidatedTreeContext> {
    pub fn default_value(&self) -> Option<DefaultValueContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 69)
            .next()
            .map(|node| DefaultValueContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated AnnotationMethodRestContext is missing required child identifier")
        };
        IdentifierContext::<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, 79).next() else {
            unreachable!("validated AnnotationMethodRestContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated AnnotationMethodRestContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct AnnotationConstantRestContext {
        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> AnnotationConstantRestContext<'a, State> {
    pub fn variable_declarators(&self) -> Result<VariableDeclaratorsContext<'a>, MissingChildError> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("AnnotationConstantRestContext", "variableDeclarators"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct DefaultValueContext {
        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> DefaultValueContext<'a, State> {
    pub fn element_value(&self) -> Result<ElementValueContext<'a>, MissingChildError> {
        __rule_children(self.__node, 60)
            .next()
            .map(|node| ElementValueContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("DefaultValueContext", "elementValue"))
    }
    pub fn default_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("DefaultValueContext", "DEFAULT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> DefaultValueContext<'a, ValidatedTreeContext> {
    pub fn element_value(&self) -> ElementValueContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 60).next() else {
            unreachable!("validated DefaultValueContext is missing required child elementValue")
        };
        ElementValueContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn default_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 12).next() else {
            unreachable!("validated DefaultValueContext is missing required child DEFAULT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ModuleDeclarationContext {
        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> ModuleDeclarationContext<'a, State> {
    pub fn qualified_name(&self) -> Result<QualifiedNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ModuleDeclarationContext", "qualifiedName"))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_directive_children(&self) -> impl Iterator<Item = ModuleDirectiveContext<'a>> + '_ {
        __rule_children(self.__node, 71)
            .map(move |node| ModuleDirectiveContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ModuleDeclarationContext", "MODULE"))
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ModuleDeclarationContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ModuleDeclarationContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ModuleDeclarationContext<'a, ValidatedTreeContext> {
    pub fn qualified_name(&self) -> QualifiedNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 52).next() else {
            unreachable!("validated ModuleDeclarationContext is missing required child qualifiedName")
        };
        QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_directive_children(&self) -> impl Iterator<Item = ModuleDirectiveContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 71)
            .map(move |node| ModuleDirectiveContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn module_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 31).next() else {
            unreachable!("validated ModuleDeclarationContext is missing required child MODULE")
        };
        TerminalNode::new(node)
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 81).next() else {
            unreachable!("validated ModuleDeclarationContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated ModuleDeclarationContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ModuleDirectiveContext {
        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> ModuleDirectiveContext<'a, State> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn requires_modifier_children(&self) -> impl Iterator<Item = RequiresModifierContext<'a>> + '_ {
        __rule_children(self.__node, 72)
            .map(move |node| RequiresModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ModuleDirectiveContext", "SEMI"))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ModuleDirectiveContext<'a, ValidatedTreeContext> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn requires_modifier_children(&self) -> impl Iterator<Item = RequiresModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 72)
            .map(move |node| RequiresModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 85).next() else {
            unreachable!("validated ModuleDirectiveContext is missing required child SEMI")
        };
        TerminalNode::new(node)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RequiresModifierContext {
        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> RequiresModifierContext<'a, State> {
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RequiresModifierContext<'a, ValidatedTreeContext> {
    pub fn static_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 48)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordDeclarationContext {
        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> RecordDeclarationContext<'a, State> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_header(&self) -> Result<RecordHeaderContext<'a>, MissingChildError> {
        __rule_children(self.__node, 74)
            .next()
            .map(|node| RecordHeaderContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "recordHeader"))
    }
    pub fn record_body(&self) -> Result<RecordBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 77)
            .next()
            .map(|node| RecordBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "recordBody"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "identifier"))
    }
    pub fn type_list(&self) -> Option<TypeListContext<'a>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| TypeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn record_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordDeclarationContext", "RECORD"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordDeclarationContext<'a, ValidatedTreeContext> {
    pub fn type_parameters(&self) -> Option<TypeParametersContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 9)
            .next()
            .map(|node| TypeParametersContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn record_header(&self) -> RecordHeaderContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 74).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child recordHeader")
        };
        RecordHeaderContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn record_body(&self) -> RecordBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 77).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child recordBody")
        };
        RecordBodyContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_list(&self) -> Option<TypeListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| TypeListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn implements_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 25)
            .next()
            .map(TerminalNode::new)
    }
    pub fn record_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 43).next() else {
            unreachable!("validated RecordDeclarationContext is missing required child RECORD")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordHeaderContext {
        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> RecordHeaderContext<'a, State> {
    pub fn record_component_list(&self) -> Option<RecordComponentListContext<'a>> {
        __rule_children(self.__node, 75)
            .next()
            .map(|node| RecordComponentListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordHeaderContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordHeaderContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordHeaderContext<'a, ValidatedTreeContext> {
    pub fn record_component_list(&self) -> Option<RecordComponentListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 75)
            .next()
            .map(|node| RecordComponentListContext::<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, 79).next() else {
            unreachable!("validated RecordHeaderContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated RecordHeaderContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordComponentListContext {
        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> RecordComponentListContext<'a, State> {
    pub fn record_component_children(&self) -> impl Iterator<Item = RecordComponentContext<'a>> + '_ {
        __rule_children(self.__node, 76)
            .map(move |node| RecordComponentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordComponentListContext<'a, ValidatedTreeContext> {
    pub fn record_component_children(&self) -> impl Iterator<Item = RecordComponentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 76)
            .map(move |node| RecordComponentContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordComponentContext {
        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> RecordComponentContext<'a, State> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordComponentContext", "identifier"))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("RecordComponentContext", "typeType"))
    }
    pub fn ellipsis_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordComponentContext<'a, ValidatedTreeContext> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated RecordComponentContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated RecordComponentContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn ellipsis_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 125)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct RecordBodyContext {
        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> RecordBodyContext<'a, State> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn compact_constructor_declaration_children(&self) -> impl Iterator<Item = CompactConstructorDeclarationContext<'a>> + '_ {
        __rule_children(self.__node, 27)
            .map(move |node| CompactConstructorDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordBodyContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("RecordBodyContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> RecordBodyContext<'a, ValidatedTreeContext> {
    pub fn class_body_declaration_children(&self) -> impl Iterator<Item = ClassBodyDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 19)
            .map(move |node| ClassBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn compact_constructor_declaration_children(&self) -> impl Iterator<Item = CompactConstructorDeclarationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 27)
            .map(move |node| CompactConstructorDeclarationContext::<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, 81).next() else {
            unreachable!("validated RecordBodyContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated RecordBodyContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BlockContext {
        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> BlockContext<'a, State> {
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BlockContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("BlockContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BlockContext<'a, ValidatedTreeContext> {
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::<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, 81).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, 82).next() else {
            unreachable!("validated BlockContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BlockStatementContext {
        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> BlockStatementContext<'a, State> {
    pub fn local_variable_declaration(&self) -> Option<LocalVariableDeclarationContext<'a>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| LocalVariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_type_declaration(&self) -> Option<LocalTypeDeclarationContext<'a>> {
        __rule_children(self.__node, 83)
            .next()
            .map(|node| LocalTypeDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Option<StatementContext<'a>> {
        __rule_children(self.__node, 84)
            .next()
            .map(|node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BlockStatementContext<'a, ValidatedTreeContext> {
    pub fn local_variable_declaration(&self) -> Option<LocalVariableDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn local_type_declaration(&self) -> Option<LocalTypeDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 83)
            .next()
            .map(|node| LocalTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement(&self) -> Option<StatementContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 84)
            .next()
            .map(|node| StatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalVariableDeclarationContext {
        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> LocalVariableDeclarationContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarators(&self) -> Option<VariableDeclaratorsContext<'a>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalVariableDeclarationContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarators(&self) -> Option<VariableDeclaratorsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct IdentifierContext {
        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> IdentifierContext<'a, State> {
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn module_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> IdentifierContext<'a, ValidatedTreeContext> {
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn module_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn permits_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 38)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn record_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 43)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn when_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeIdentifierContext {
        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> TypeIdentifierContext<'a, State> {
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn module_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeIdentifierContext<'a, ValidatedTreeContext> {
    pub fn exports_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 17)
            .next()
            .map(TerminalNode::new)
    }
    pub fn module_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 31)
            .next()
            .map(TerminalNode::new)
    }
    pub fn open_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 35)
            .next()
            .map(TerminalNode::new)
    }
    pub fn opens_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 36)
            .next()
            .map(TerminalNode::new)
    }
    pub fn provides_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 41)
            .next()
            .map(TerminalNode::new)
    }
    pub fn requires_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 44)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sealed_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 46)
            .next()
            .map(TerminalNode::new)
    }
    pub fn to_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 56)
            .next()
            .map(TerminalNode::new)
    }
    pub fn transitive_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 58)
            .next()
            .map(TerminalNode::new)
    }
    pub fn uses_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 60)
            .next()
            .map(TerminalNode::new)
    }
    pub fn with_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 66)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LocalTypeDeclarationContext {
        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> LocalTypeDeclarationContext<'a, State> {
    pub fn class_or_interface_modifier_children(&self) -> impl Iterator<Item = ClassOrInterfaceModifierContext<'a>> + '_ {
        __rule_children(self.__node, 6)
            .map(move |node| ClassOrInterfaceModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a>> {
        __rule_children(self.__node, 16)
            .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, 73)
            .next()
            .map(|node| RecordDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LocalTypeDeclarationContext<'a, ValidatedTreeContext> {
    pub fn class_or_interface_modifier_children(&self) -> impl Iterator<Item = ClassOrInterfaceModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 6)
            .map(move |node| ClassOrInterfaceModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_declaration(&self) -> Option<ClassDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 8)
            .next()
            .map(|node| ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_declaration(&self) -> Option<EnumDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 12)
            .next()
            .map(|node| EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn interface_declaration(&self) -> Option<InterfaceDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 16)
            .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, 73)
            .next()
            .map(|node| RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct StatementContext {
        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> StatementContext<'a, State> {
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn statement_children(&self) -> impl Iterator<Item = StatementContext<'a>> + '_ {
        __rule_children(self.__node, 84)
            .map(move |node| StatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn catch_clause_children(&self) -> impl Iterator<Item = CatchClauseContext<'a>> + '_ {
        __rule_children(self.__node, 85)
            .map(move |node| CatchClauseContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn finally_block(&self) -> Option<FinallyBlockContext<'a>> {
        __rule_children(self.__node, 87)
            .next()
            .map(|node| FinallyBlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn resource_specification(&self) -> Option<ResourceSpecificationContext<'a>> {
        __rule_children(self.__node, 88)
            .next()
            .map(|node| ResourceSpecificationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_block_statement_group_children(&self) -> impl Iterator<Item = SwitchBlockStatementGroupContext<'a>> + '_ {
        __rule_children(self.__node, 91)
            .map(move |node| SwitchBlockStatementGroupContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_label_children(&self) -> impl Iterator<Item = SwitchLabelContext<'a>> + '_ {
        __rule_children(self.__node, 92)
            .map(move |node| SwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_control(&self) -> Option<ForControlContext<'a>> {
        __rule_children(self.__node, 93)
            .next()
            .map(|node| ForControlContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression(&self) -> Option<SwitchExpressionContext<'a>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| SwitchExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assert_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 2)
            .next()
            .map(TerminalNode::new)
    }
    pub fn break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn continue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 11)
            .next()
            .map(TerminalNode::new)
    }
    pub fn do_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 13)
            .next()
            .map(TerminalNode::new)
    }
    pub fn else_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn for_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
    }
    pub fn if_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 45)
            .next()
            .map(TerminalNode::new)
    }
    pub fn switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
    }
    pub fn synchronized_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn throw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn try_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn while_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 65)
            .next()
            .map(TerminalNode::new)
    }
    pub fn yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> StatementContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<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, 84)
            .map(move |node| StatementContext::<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, 85)
            .map(move |node| CatchClauseContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn finally_block(&self) -> Option<FinallyBlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 87)
            .next()
            .map(|node| FinallyBlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn resource_specification(&self) -> Option<ResourceSpecificationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 88)
            .next()
            .map(|node| ResourceSpecificationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_block_statement_group_children(&self) -> impl Iterator<Item = SwitchBlockStatementGroupContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 91)
            .map(move |node| SwitchBlockStatementGroupContext::<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, 92)
            .map(move |node| SwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn for_control(&self) -> Option<ForControlContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 93)
            .next()
            .map(|node| ForControlContext::<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, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression(&self) -> Option<SwitchExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| SwitchExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assert_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 2)
            .next()
            .map(TerminalNode::new)
    }
    pub fn break_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 4)
            .next()
            .map(TerminalNode::new)
    }
    pub fn continue_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 11)
            .next()
            .map(TerminalNode::new)
    }
    pub fn do_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 13)
            .next()
            .map(TerminalNode::new)
    }
    pub fn else_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 15)
            .next()
            .map(TerminalNode::new)
    }
    pub fn for_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 22)
            .next()
            .map(TerminalNode::new)
    }
    pub fn if_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 24)
            .next()
            .map(TerminalNode::new)
    }
    pub fn return_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 45)
            .next()
            .map(TerminalNode::new)
    }
    pub fn switch_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
    }
    pub fn synchronized_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 52)
            .next()
            .map(TerminalNode::new)
    }
    pub fn throw_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 54)
            .next()
            .map(TerminalNode::new)
    }
    pub fn try_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 59)
            .next()
            .map(TerminalNode::new)
    }
    pub fn while_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 65)
            .next()
            .map(TerminalNode::new)
    }
    pub fn yield_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 67)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrace_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CatchClauseContext {
        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> CatchClauseContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "block"))
    }
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "identifier"))
    }
    pub fn catch_type(&self) -> Result<CatchTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 86)
            .next()
            .map(|node| CatchTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "catchType"))
    }
    pub fn catch_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 7)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "CATCH"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CatchClauseContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CatchClauseContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<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, 78).next() else {
            unreachable!("validated CatchClauseContext is missing required child block")
        };
        BlockContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated CatchClauseContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn catch_type(&self) -> CatchTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 86).next() else {
            unreachable!("validated CatchClauseContext is missing required child catchType")
        };
        CatchTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn catch_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 7).next() else {
            unreachable!("validated CatchClauseContext is missing required child CATCH")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 79).next() else {
            unreachable!("validated CatchClauseContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated CatchClauseContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CatchTypeContext {
        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> CatchTypeContext<'a, State> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bitor_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 108).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CatchTypeContext<'a, ValidatedTreeContext> {
    pub fn qualified_name_children(&self) -> impl Iterator<Item = QualifiedNameContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 52)
            .map(move |node| QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn bitor_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 108).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct FinallyBlockContext {
        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> FinallyBlockContext<'a, State> {
    pub fn block(&self) -> Result<BlockContext<'a>, MissingChildError> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("FinallyBlockContext", "block"))
    }
    pub fn finally_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 20)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("FinallyBlockContext", "FINALLY"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct ResourceSpecificationContext {
        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> ResourceSpecificationContext<'a, State> {
    pub fn resources(&self) -> Result<ResourcesContext<'a>, MissingChildError> {
        __rule_children(self.__node, 89)
            .next()
            .map(|node| ResourcesContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ResourceSpecificationContext", "resources"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ResourceSpecificationContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ResourceSpecificationContext", "RPAREN"))
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ResourceSpecificationContext<'a, ValidatedTreeContext> {
    pub fn resources(&self) -> ResourcesContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 89).next() else {
            unreachable!("validated ResourceSpecificationContext is missing required child resources")
        };
        ResourcesContext::<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, 79).next() else {
            unreachable!("validated ResourceSpecificationContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated ResourceSpecificationContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn semi_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 85)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ResourcesContext {
        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> ResourcesContext<'a, State> {
    pub fn resource_children(&self) -> impl Iterator<Item = ResourceContext<'a>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| ResourceContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ResourcesContext<'a, ValidatedTreeContext> {
    pub fn resource_children(&self) -> impl Iterator<Item = ResourceContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 90)
            .map(move |node| ResourceContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ResourceContext {
        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> ResourceContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> Option<VariableDeclaratorIdContext<'a>> {
        __rule_children(self.__node, 39)
            .next()
            .map(|node| VariableDeclaratorIdContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn qualified_name(&self) -> Option<QualifiedNameContext<'a>> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_interface_type(&self) -> Option<ClassOrInterfaceTypeContext<'a>> {
        __rule_children(self.__node, 111)
            .next()
            .map(|node| ClassOrInterfaceTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ResourceContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> Option<VariableDeclaratorIdContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 39)
            .next()
            .map(|node| VariableDeclaratorIdContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn qualified_name(&self) -> Option<QualifiedNameContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 52)
            .next()
            .map(|node| QualifiedNameContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_interface_type(&self) -> Option<ClassOrInterfaceTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 111)
            .next()
            .map(|node| ClassOrInterfaceTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchBlockStatementGroupContext {
        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> SwitchBlockStatementGroupContext<'a, State> {
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_label_children(&self) -> impl Iterator<Item = SwitchLabelContext<'a>> + '_ {
        __rule_children(self.__node, 92)
            .map(move |node| SwitchLabelContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn colon_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 94).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchBlockStatementGroupContext<'a, ValidatedTreeContext> {
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::<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, 92)
            .map(move |node| SwitchLabelContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn colon_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 94).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchLabelContext {
        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> SwitchLabelContext<'a, State> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn constant_expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .nth(0)
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_constant_name(&self) -> Option<TerminalNode<'a>> {
        __labeled_token_children(self.__node, 129)
            .nth(0)
            .map(TerminalNode::new)
    }
    pub fn var_name(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .nth(0)
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchLabelContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn identifier_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 129)
            .next()
            .map(TerminalNode::new)
    }
    pub fn constant_expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .nth(0)
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enum_constant_name(&self) -> Option<TerminalNode<'a>> {
        __labeled_token_children(self.__node, 129)
            .nth(0)
            .map(TerminalNode::new)
    }
    pub fn var_name(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .nth(0)
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ForControlContext {
        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> ForControlContext<'a, State> {
    pub fn for_init(&self) -> Option<ForInitContext<'a>> {
        __rule_children(self.__node, 94)
            .next()
            .map(|node| ForInitContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enhanced_for_control(&self) -> Option<EnhancedForControlContext<'a>> {
        __rule_children(self.__node, 95)
            .next()
            .map(|node| EnhancedForControlContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
    pub fn for_update(&self) -> Option<ExpressionListContext<'a>> {
        __rule_children(self.__node, 96)
            .nth(0)
            .map(|node| ExpressionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ForControlContext<'a, ValidatedTreeContext> {
    pub fn for_init(&self) -> Option<ForInitContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 94)
            .next()
            .map(|node| ForInitContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn enhanced_for_control(&self) -> Option<EnhancedForControlContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 95)
            .next()
            .map(|node| EnhancedForControlContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn semi_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 85).map(TerminalNode::new)
    }
    pub fn for_update(&self) -> Option<ExpressionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .nth(0)
            .map(|node| ExpressionListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ForInitContext {
        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> ForInitContext<'a, State> {
    pub fn local_variable_declaration(&self) -> Option<LocalVariableDeclarationContext<'a>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| LocalVariableDeclarationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ForInitContext<'a, ValidatedTreeContext> {
    pub fn local_variable_declaration(&self) -> Option<LocalVariableDeclarationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 80)
            .next()
            .map(|node| LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct EnhancedForControlContext {
        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> EnhancedForControlContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> Result<VariableDeclaratorIdContext<'a>, MissingChildError> {
        __rule_children(self.__node, 39)
            .next()
            .map(|node| VariableDeclaratorIdContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnhancedForControlContext", "variableDeclaratorId"))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("EnhancedForControlContext", "expression"))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("EnhancedForControlContext", "COLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> EnhancedForControlContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarator_id(&self) -> VariableDeclaratorIdContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 39).next() else {
            unreachable!("validated EnhancedForControlContext is missing required child variableDeclaratorId")
        };
        VariableDeclaratorIdContext::<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, 98).next() else {
            unreachable!("validated EnhancedForControlContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn var_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 61)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 94).next() else {
            unreachable!("validated EnhancedForControlContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionListContext {
        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> ExpressionListContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .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, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionListContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 98)
            .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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodCallContext {
        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> MethodCallContext<'a, State> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Result<ArgumentsContext<'a>, MissingChildError> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodCallContext", "arguments"))
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MethodCallContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> ArgumentsContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 127).next() else {
            unreachable!("validated MethodCallContext is missing required child arguments")
        };
        ArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionContext {
        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> ExpressionContext<'a, State> {
    pub fn class_type(&self) -> Option<ClassTypeContext<'a>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| ClassTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_call(&self) -> Option<MethodCallContext<'a>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| MethodCallContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn pattern(&self) -> Option<PatternContext<'a>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_expression(&self) -> Option<LambdaExpressionContext<'a>> {
        __rule_children(self.__node, 102)
            .next()
            .map(|node| LambdaExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primary(&self) -> Option<PrimaryContext<'a>> {
        __rule_children(self.__node, 105)
            .next()
            .map(|node| PrimaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression(&self) -> Option<SwitchExpressionContext<'a>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| SwitchExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn creator(&self) -> Option<CreatorContext<'a>> {
        __rule_children(self.__node, 112)
            .next()
            .map(|node| CreatorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn inner_creator(&self) -> Option<InnerCreatorContext<'a>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| InnerCreatorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation(&self) -> Option<ExplicitGenericInvocationContext<'a>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| ExplicitGenericInvocationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instanceof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrack_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 89).map(TerminalNode::new)
    }
    pub fn lt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 90).map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn equal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn notequal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
    pub fn bitor_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn xor_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn urshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn coloncolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExpressionContext<'a, ValidatedTreeContext> {
    pub fn class_type(&self) -> Option<ClassTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| ClassTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_call(&self) -> Option<MethodCallContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| MethodCallContext::<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, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn pattern(&self) -> Option<PatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_expression(&self) -> Option<LambdaExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 102)
            .next()
            .map(|node| LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primary(&self) -> Option<PrimaryContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 105)
            .next()
            .map(|node| PrimaryContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_expression(&self) -> Option<SwitchExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| SwitchExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn creator(&self) -> Option<CreatorContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 112)
            .next()
            .map(|node| CreatorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn inner_creator(&self) -> Option<InnerCreatorContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| InnerCreatorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation(&self) -> Option<ExplicitGenericInvocationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| ExplicitGenericInvocationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instanceof_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lbrack_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rbrack_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 89).map(TerminalNode::new)
    }
    pub fn lt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 90).map(TerminalNode::new)
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn question_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn equal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn notequal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
    pub fn bitor_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn xor_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn urshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
    pub fn coloncolon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PrimaryExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(99),
        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> PrimaryExpressionLabelContext<'a, State> {
    pub fn primary(&self) -> Result<PrimaryContext<'a>, MissingChildError> {
        __rule_children(self.__node, 105)
            .next()
            .map(|node| PrimaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PrimaryExpressionLabelContext", "primary"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct SquareBracketExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(100),
        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> SquareBracketExpressionLabelContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 83)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SquareBracketExpressionLabelContext", "LBRACK"))
    }
    pub fn rbrack_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 84)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SquareBracketExpressionLabelContext", "RBRACK"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SquareBracketExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 83).next() else {
            unreachable!("validated SquareBracketExpressionLabelContext is missing required child LBRACK")
        };
        TerminalNode::new(node)
    }
    pub fn rbrack_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 84).next() else {
            unreachable!("validated SquareBracketExpressionLabelContext is missing required child RBRACK")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MemberReferenceExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(101),
        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> MemberReferenceExpressionLabelContext<'a, State> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_call(&self) -> Option<MethodCallContext<'a>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| MethodCallContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MemberReferenceExpressionLabelContext", "expression"))
    }
    pub fn inner_creator(&self) -> Option<InnerCreatorContext<'a>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| InnerCreatorContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation(&self) -> Option<ExplicitGenericInvocationContext<'a>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| ExplicitGenericInvocationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MemberReferenceExpressionLabelContext", "DOT"))
    }
    pub fn bop(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __labeled_token_children(self.__node, 87)
            .nth(0)
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MemberReferenceExpressionLabelContext", "bop"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MemberReferenceExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn method_call(&self) -> Option<MethodCallContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| MethodCallContext::<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, 98).next() else {
            unreachable!("validated MemberReferenceExpressionLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn inner_creator(&self) -> Option<InnerCreatorContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 114)
            .next()
            .map(|node| InnerCreatorContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation(&self) -> Option<ExplicitGenericInvocationContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 117)
            .next()
            .map(|node| ExplicitGenericInvocationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 87).next() else {
            unreachable!("validated MemberReferenceExpressionLabelContext is missing required child DOT")
        };
        TerminalNode::new(node)
    }
    pub fn bop(&self) -> TerminalNode<'a> {
        let Some(node) = __labeled_token_children(self.__node, 87)
            .nth(0)
        else {
            unreachable!("validated MemberReferenceExpressionLabelContext is missing required child bop")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodCallExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(102),
        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> MethodCallExpressionLabelContext<'a, State> {
    pub fn method_call(&self) -> Result<MethodCallContext<'a>, MissingChildError> {
        __rule_children(self.__node, 97)
            .next()
            .map(|node| MethodCallContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("MethodCallExpressionLabelContext", "methodCall"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct MethodReferenceExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(103),
        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> MethodReferenceExpressionLabelContext<'a, State> {
    pub fn class_type(&self) -> Option<ClassTypeContext<'a>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| ClassTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn coloncolon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 123)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("MethodReferenceExpressionLabelContext", "COLONCOLON"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> MethodReferenceExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn class_type(&self) -> Option<ClassTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| ClassTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn new_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
    }
    pub fn coloncolon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 123).next() else {
            unreachable!("validated MethodReferenceExpressionLabelContext is missing required child COLONCOLON")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionSwitchLabelContext {
        rule_index: 98,
        context_kind: exact(104),
        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> ExpressionSwitchLabelContext<'a, State> {
    pub fn switch_expression(&self) -> Result<SwitchExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 106)
            .next()
            .map(|node| SwitchExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExpressionSwitchLabelContext", "switchExpression"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct PostIncrementDecrementOperatorExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(105),
        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> PostIncrementDecrementOperatorExpressionLabelContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PostIncrementDecrementOperatorExpressionLabelContext", "expression"))
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn postfix(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __labeled_token_children_matching(self.__node, &[101, 102])
            .nth(0)
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("PostIncrementDecrementOperatorExpressionLabelContext", "postfix"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PostIncrementDecrementOperatorExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 98).next() else {
            unreachable!("validated PostIncrementDecrementOperatorExpressionLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn postfix(&self) -> TerminalNode<'a> {
        let Some(node) = __labeled_token_children_matching(self.__node, &[101, 102])
            .nth(0)
        else {
            unreachable!("validated PostIncrementDecrementOperatorExpressionLabelContext is missing required child postfix")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct UnaryOperatorExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(106),
        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> UnaryOperatorExpressionLabelContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("UnaryOperatorExpressionLabelContext", "expression"))
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn prefix(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __labeled_token_children_matching(self.__node, &[91, 92, 101, 102, 103, 104])
            .nth(0)
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("UnaryOperatorExpressionLabelContext", "prefix"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> UnaryOperatorExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 98).next() else {
            unreachable!("validated UnaryOperatorExpressionLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn bang_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 91)
            .next()
            .map(TerminalNode::new)
    }
    pub fn tilde_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 92)
            .next()
            .map(TerminalNode::new)
    }
    pub fn inc_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 101)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dec_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 102)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn prefix(&self) -> TerminalNode<'a> {
        let Some(node) = __labeled_token_children_matching(self.__node, &[91, 92, 101, 102, 103, 104])
            .nth(0)
        else {
            unreachable!("validated UnaryOperatorExpressionLabelContext is missing required child prefix")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CastExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(107),
        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> CastExpressionLabelContext<'a, State> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CastExpressionLabelContext", "expression"))
    }
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CastExpressionLabelContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("CastExpressionLabelContext", "RPAREN"))
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CastExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<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, 98).next() else {
            unreachable!("validated CastExpressionLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::<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, 79).next() else {
            unreachable!("validated CastExpressionLabelContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated CastExpressionLabelContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn bitand_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 107).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ObjectCreationExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(108),
        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> ObjectCreationExpressionLabelContext<'a, State> {
    pub fn creator(&self) -> Result<CreatorContext<'a>, MissingChildError> {
        __rule_children(self.__node, 112)
            .next()
            .map(|node| CreatorContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ObjectCreationExpressionLabelContext", "creator"))
    }
    pub fn new_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 33)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ObjectCreationExpressionLabelContext", "NEW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ObjectCreationExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn creator(&self) -> CreatorContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 112).next() else {
            unreachable!("validated ObjectCreationExpressionLabelContext is missing required child creator")
        };
        CreatorContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn new_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 33).next() else {
            unreachable!("validated ObjectCreationExpressionLabelContext is missing required child NEW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct BinaryOperatorExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(109),
        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> BinaryOperatorExpressionLabelContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 89).map(TerminalNode::new)
    }
    pub fn lt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 90).map(TerminalNode::new)
    }
    pub fn equal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn notequal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitand_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitor_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn xor_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn urshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> BinaryOperatorExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 88)
            .next()
            .map(TerminalNode::new)
    }
    pub fn gt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 89).map(TerminalNode::new)
    }
    pub fn lt_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 90).map(TerminalNode::new)
    }
    pub fn equal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 95)
            .next()
            .map(TerminalNode::new)
    }
    pub fn le_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 96)
            .next()
            .map(TerminalNode::new)
    }
    pub fn ge_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 97)
            .next()
            .map(TerminalNode::new)
    }
    pub fn notequal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 98)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 99)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 100)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 103)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 104)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 105)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 106)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitand_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 107)
            .next()
            .map(TerminalNode::new)
    }
    pub fn bitor_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 108)
            .next()
            .map(TerminalNode::new)
    }
    pub fn caret_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 109)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 110)
            .next()
            .map(TerminalNode::new)
    }
    pub fn add_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 111)
            .next()
            .map(TerminalNode::new)
    }
    pub fn sub_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 112)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mul_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 113)
            .next()
            .map(TerminalNode::new)
    }
    pub fn div_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 114)
            .next()
            .map(TerminalNode::new)
    }
    pub fn and_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 115)
            .next()
            .map(TerminalNode::new)
    }
    pub fn or_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 116)
            .next()
            .map(TerminalNode::new)
    }
    pub fn xor_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 117)
            .next()
            .map(TerminalNode::new)
    }
    pub fn mod_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 118)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 119)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 120)
            .next()
            .map(TerminalNode::new)
    }
    pub fn urshift_assign_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 121)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InstanceOfOperatorExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(110),
        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> InstanceOfOperatorExpressionLabelContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InstanceOfOperatorExpressionLabelContext", "expression"))
    }
    pub fn pattern(&self) -> Option<PatternContext<'a>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instanceof_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 27)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InstanceOfOperatorExpressionLabelContext", "INSTANCEOF"))
    }
    pub fn bop(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __labeled_token_children(self.__node, 27)
            .nth(0)
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("InstanceOfOperatorExpressionLabelContext", "bop"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InstanceOfOperatorExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 98).next() else {
            unreachable!("validated InstanceOfOperatorExpressionLabelContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn pattern(&self) -> Option<PatternContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Option<TypeTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn instanceof_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 27).next() else {
            unreachable!("validated InstanceOfOperatorExpressionLabelContext is missing required child INSTANCEOF")
        };
        TerminalNode::new(node)
    }
    pub fn bop(&self) -> TerminalNode<'a> {
        let Some(node) = __labeled_token_children(self.__node, 27)
            .nth(0)
        else {
            unreachable!("validated InstanceOfOperatorExpressionLabelContext is missing required child bop")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TernaryExpressionLabelContext {
        rule_index: 98,
        context_kind: exact(111),
        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> TernaryExpressionLabelContext<'a, State> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn question_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 93)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TernaryExpressionLabelContext", "QUESTION"))
    }
    pub fn colon_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TernaryExpressionLabelContext", "COLON"))
    }
    pub fn bop(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __labeled_token_children(self.__node, 93)
            .nth(0)
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TernaryExpressionLabelContext", "bop"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TernaryExpressionLabelContext<'a, ValidatedTreeContext> {
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn question_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 93).next() else {
            unreachable!("validated TernaryExpressionLabelContext is missing required child QUESTION")
        };
        TerminalNode::new(node)
    }
    pub fn colon_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 94).next() else {
            unreachable!("validated TernaryExpressionLabelContext is missing required child COLON")
        };
        TerminalNode::new(node)
    }
    pub fn bop(&self) -> TerminalNode<'a> {
        let Some(node) = __labeled_token_children(self.__node, 93)
            .nth(0)
        else {
            unreachable!("validated TernaryExpressionLabelContext is missing required child bop")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExpressionLambdaLabelContext {
        rule_index: 98,
        context_kind: exact(112),
        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> ExpressionLambdaLabelContext<'a, State> {
    pub fn lambda_expression(&self) -> Result<LambdaExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 102)
            .next()
            .map(|node| LambdaExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExpressionLambdaLabelContext", "lambdaExpression"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct PatternContext {
        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> PatternContext<'a, State> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarators(&self) -> Option<VariableDeclaratorsContext<'a>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn component_pattern_list(&self) -> Option<ComponentPatternListContext<'a>> {
        __rule_children(self.__node, 100)
            .next()
            .map(|node| ComponentPatternListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> Result<TypeTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 122)
            .next()
            .map(|node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("PatternContext", "typeType"))
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PatternContext<'a, ValidatedTreeContext> {
    pub fn variable_modifier_children(&self) -> impl Iterator<Item = VariableModifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 7)
            .map(move |node| VariableModifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn variable_declarators(&self) -> Option<VariableDeclaratorsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 37)
            .next()
            .map(|node| VariableDeclaratorsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn component_pattern_list(&self) -> Option<ComponentPatternListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 100)
            .next()
            .map(|node| ComponentPatternListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_type(&self) -> TypeTypeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 122).next() else {
            unreachable!("validated PatternContext is missing required child typeType")
        };
        TypeTypeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ComponentPatternListContext {
        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> ComponentPatternListContext<'a, State> {
    pub fn component_pattern_children(&self) -> impl Iterator<Item = ComponentPatternContext<'a>> + '_ {
        __rule_children(self.__node, 101)
            .map(move |node| ComponentPatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ComponentPatternListContext<'a, ValidatedTreeContext> {
    pub fn component_pattern_children(&self) -> impl Iterator<Item = ComponentPatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 101)
            .map(move |node| ComponentPatternContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ComponentPatternContext {
        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> ComponentPatternContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ComponentPatternContext", "pattern"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaExpressionContext {
        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> LambdaExpressionContext<'a, State> {
    pub fn lambda_parameters(&self) -> Result<LambdaParametersContext<'a>, MissingChildError> {
        __rule_children(self.__node, 103)
            .next()
            .map(|node| LambdaParametersContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LambdaExpressionContext", "lambdaParameters"))
    }
    pub fn lambda_body(&self) -> Result<LambdaBodyContext<'a>, MissingChildError> {
        __rule_children(self.__node, 104)
            .next()
            .map(|node| LambdaBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("LambdaExpressionContext", "lambdaBody"))
    }
    pub fn arrow_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("LambdaExpressionContext", "ARROW"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaExpressionContext<'a, ValidatedTreeContext> {
    pub fn lambda_parameters(&self) -> LambdaParametersContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 103).next() else {
            unreachable!("validated LambdaExpressionContext is missing required child lambdaParameters")
        };
        LambdaParametersContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn lambda_body(&self) -> LambdaBodyContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 104).next() else {
            unreachable!("validated LambdaExpressionContext is missing required child lambdaBody")
        };
        LambdaBodyContext::<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, 122).next() else {
            unreachable!("validated LambdaExpressionContext is missing required child ARROW")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaParametersContext {
        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> LambdaParametersContext<'a, State> {
    pub fn formal_parameter_list(&self) -> Option<FormalParameterListContext<'a>> {
        __rule_children(self.__node, 48)
            .next()
            .map(|node| FormalParameterListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_lvti_list(&self) -> Option<LambdaLvtiListContext<'a>> {
        __rule_children(self.__node, 50)
            .next()
            .map(|node| LambdaLvtiListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaParametersContext<'a, ValidatedTreeContext> {
    pub fn formal_parameter_list(&self) -> Option<FormalParameterListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 48)
            .next()
            .map(|node| FormalParameterListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lambda_lvti_list(&self) -> Option<LambdaLvtiListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 50)
            .next()
            .map(|node| LambdaLvtiListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct LambdaBodyContext {
        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> LambdaBodyContext<'a, State> {
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> LambdaBodyContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 78)
            .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, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PrimaryContext {
        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> PrimaryContext<'a, State> {
    pub fn type_type_or_void(&self) -> Option<TypeTypeOrVoidContext<'a>> {
        __rule_children(self.__node, 23)
            .next()
            .map(|node| TypeTypeOrVoidContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn literal(&self) -> Option<LiteralContext<'a>> {
        __rule_children(self.__node, 53)
            .next()
            .map(|node| LiteralContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation_suffix(&self) -> Option<ExplicitGenericInvocationSuffixContext<'a>> {
        __rule_children(self.__node, 126)
            .next()
            .map(|node| ExplicitGenericInvocationSuffixContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PrimaryContext<'a, ValidatedTreeContext> {
    pub fn type_type_or_void(&self) -> Option<TypeTypeOrVoidContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 23)
            .next()
            .map(|node| TypeTypeOrVoidContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn literal(&self) -> Option<LiteralContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 53)
            .next()
            .map(|node| LiteralContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression(&self) -> Option<ExpressionContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn explicit_generic_invocation_suffix(&self) -> Option<ExplicitGenericInvocationSuffixContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 126)
            .next()
            .map(|node| ExplicitGenericInvocationSuffixContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 9)
            .next()
            .map(TerminalNode::new)
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
    pub fn this_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 53)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
    }
    pub fn rparen_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchExpressionContext {
        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> SwitchExpressionContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "expression"))
    }
    pub fn switch_labeled_rule_children(&self) -> impl Iterator<Item = SwitchLabeledRuleContext<'a>> + '_ {
        __rule_children(self.__node, 107)
            .map(move |node| SwitchLabeledRuleContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 51)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "SWITCH"))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "RPAREN"))
    }
    pub fn lbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 81)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "LBRACE"))
    }
    pub fn rbrace_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 82)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("SwitchExpressionContext", "RBRACE"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchExpressionContext<'a, ValidatedTreeContext> {
    pub fn expression(&self) -> ExpressionContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 98).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child expression")
        };
        ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn switch_labeled_rule_children(&self) -> impl Iterator<Item = SwitchLabeledRuleContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 107)
            .map(move |node| SwitchLabeledRuleContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 51).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child SWITCH")
        };
        TerminalNode::new(node)
    }
    pub fn lparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 79).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn lbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 81).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child LBRACE")
        };
        TerminalNode::new(node)
    }
    pub fn rbrace_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 82).next() else {
            unreachable!("validated SwitchExpressionContext is missing required child RBRACE")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchLabeledRuleContext {
        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> SwitchLabeledRuleContext<'a, State> {
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn guard(&self) -> Option<GuardContext<'a>> {
        __rule_children(self.__node, 108)
            .next()
            .map(|node| GuardContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_pattern_children(&self) -> impl Iterator<Item = CasePatternContext<'a>> + '_ {
        __rule_children(self.__node, 109)
            .map(move |node| CasePatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_rule_outcome(&self) -> Result<SwitchRuleOutcomeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 110)
            .next()
            .map(|node| SwitchRuleOutcomeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("SwitchLabeledRuleContext", "switchRuleOutcome"))
    }
    pub fn case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn null_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn arrow_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchLabeledRuleContext<'a, ValidatedTreeContext> {
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn guard(&self) -> Option<GuardContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 108)
            .next()
            .map(|node| GuardContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn case_pattern_children(&self) -> impl Iterator<Item = CasePatternContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 109)
            .map(move |node| CasePatternContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn switch_rule_outcome(&self) -> SwitchRuleOutcomeContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 110).next() else {
            unreachable!("validated SwitchLabeledRuleContext is missing required child switchRuleOutcome")
        };
        SwitchRuleOutcomeContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn case_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 6)
            .next()
            .map(TerminalNode::new)
    }
    pub fn default_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 12)
            .next()
            .map(TerminalNode::new)
    }
    pub fn null_literal_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 78)
            .next()
            .map(TerminalNode::new)
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
    pub fn colon_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 94)
            .next()
            .map(TerminalNode::new)
    }
    pub fn arrow_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 122)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct GuardContext {
        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> GuardContext<'a, State> {
    pub fn expression(&self) -> Result<ExpressionContext<'a>, MissingChildError> {
        __rule_children(self.__node, 98)
            .next()
            .map(|node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("GuardContext", "expression"))
    }
    pub fn when_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 64)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("GuardContext", "WHEN"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct CasePatternContext {
        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> CasePatternContext<'a, State> {
    pub fn pattern(&self) -> Result<PatternContext<'a>, MissingChildError> {
        __rule_children(self.__node, 99)
            .next()
            .map(|node| PatternContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CasePatternContext", "pattern"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct SwitchRuleOutcomeContext {
        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> SwitchRuleOutcomeContext<'a, State> {
    pub fn block(&self) -> Option<BlockContext<'a>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SwitchRuleOutcomeContext<'a, ValidatedTreeContext> {
    pub fn block(&self) -> Option<BlockContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 78)
            .next()
            .map(|node| BlockContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn block_statement_children(&self) -> impl Iterator<Item = BlockStatementContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 79)
            .map(move |node| BlockStatementContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassOrInterfaceTypeContext {
        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> ClassOrInterfaceTypeContext<'a, State> {
    pub fn class_type(&self) -> Result<ClassTypeContext<'a>, MissingChildError> {
        __rule_children(self.__node, 42)
            .next()
            .map(|node| ClassTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ClassOrInterfaceTypeContext", "classType"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct CreatorContext {
        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> CreatorContext<'a, State> {
    pub fn created_name(&self) -> Result<CreatedNameContext<'a>, MissingChildError> {
        __rule_children(self.__node, 113)
            .next()
            .map(|node| CreatedNameContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("CreatorContext", "createdName"))
    }
    pub fn array_creator_rest(&self) -> Option<ArrayCreatorRestContext<'a>> {
        __rule_children(self.__node, 115)
            .next()
            .map(|node| ArrayCreatorRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_creator_rest(&self) -> Option<ClassCreatorRestContext<'a>> {
        __rule_children(self.__node, 116)
            .next()
            .map(|node| ClassCreatorRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CreatorContext<'a, ValidatedTreeContext> {
    pub fn created_name(&self) -> CreatedNameContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 113).next() else {
            unreachable!("validated CreatorContext is missing required child createdName")
        };
        CreatedNameContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn array_creator_rest(&self) -> Option<ArrayCreatorRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 115)
            .next()
            .map(|node| ArrayCreatorRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_creator_rest(&self) -> Option<ClassCreatorRestContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 116)
            .next()
            .map(|node| ClassCreatorRestContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct CreatedNameContext {
        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> CreatedNameContext<'a, State> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments_or_diamond_children(&self) -> impl Iterator<Item = TypeArgumentsOrDiamondContext<'a>> + '_ {
        __rule_children(self.__node, 118)
            .map(move |node| TypeArgumentsOrDiamondContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primitive_type(&self) -> Option<PrimitiveTypeContext<'a>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| PrimitiveTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> CreatedNameContext<'a, ValidatedTreeContext> {
    pub fn identifier_children(&self) -> impl Iterator<Item = IdentifierContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 81)
            .map(move |node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments_or_diamond_children(&self) -> impl Iterator<Item = TypeArgumentsOrDiamondContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 118)
            .map(move |node| TypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primitive_type(&self) -> Option<PrimitiveTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| PrimitiveTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 87).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct InnerCreatorContext {
        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> InnerCreatorContext<'a, State> {
    pub fn identifier(&self) -> Result<IdentifierContext<'a>, MissingChildError> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InnerCreatorContext", "identifier"))
    }
    pub fn class_creator_rest(&self) -> Result<ClassCreatorRestContext<'a>, MissingChildError> {
        __rule_children(self.__node, 116)
            .next()
            .map(|node| ClassCreatorRestContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("InnerCreatorContext", "classCreatorRest"))
    }
    pub fn non_wildcard_type_arguments_or_diamond(&self) -> Option<NonWildcardTypeArgumentsOrDiamondContext<'a>> {
        __rule_children(self.__node, 119)
            .next()
            .map(|node| NonWildcardTypeArgumentsOrDiamondContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> InnerCreatorContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> IdentifierContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 81).next() else {
            unreachable!("validated InnerCreatorContext is missing required child identifier")
        };
        IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn class_creator_rest(&self) -> ClassCreatorRestContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 116).next() else {
            unreachable!("validated InnerCreatorContext is missing required child classCreatorRest")
        };
        ClassCreatorRestContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn non_wildcard_type_arguments_or_diamond(&self) -> Option<NonWildcardTypeArgumentsOrDiamondContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 119)
            .next()
            .map(|node| NonWildcardTypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArrayCreatorRestContext {
        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> ArrayCreatorRestContext<'a, State> {
    pub fn array_initializer(&self) -> Option<ArrayInitializerContext<'a>> {
        __rule_children(self.__node, 41)
            .next()
            .map(|node| ArrayInitializerContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn expression_children(&self) -> impl Iterator<Item = ExpressionContext<'a>> + '_ {
        __rule_children(self.__node, 98)
            .map(move |node| ExpressionContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArrayCreatorRestContext<'a, ValidatedTreeContext> {
    pub fn array_initializer(&self) -> Option<ArrayInitializerContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 41)
            .next()
            .map(|node| ArrayInitializerContext::<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, 98)
            .map(move |node| ExpressionContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ClassCreatorRestContext {
        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> ClassCreatorRestContext<'a, State> {
    pub fn class_body(&self) -> Option<ClassBodyContext<'a>> {
        __rule_children(self.__node, 17)
            .next()
            .map(|node| ClassBodyContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Result<ArgumentsContext<'a>, MissingChildError> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ClassCreatorRestContext", "arguments"))
    }
}

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

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExplicitGenericInvocationContext {
        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> ExplicitGenericInvocationContext<'a, State> {
    pub fn non_wildcard_type_arguments(&self) -> Result<NonWildcardTypeArgumentsContext<'a>, MissingChildError> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExplicitGenericInvocationContext", "nonWildcardTypeArguments"))
    }
    pub fn explicit_generic_invocation_suffix(&self) -> Result<ExplicitGenericInvocationSuffixContext<'a>, MissingChildError> {
        __rule_children(self.__node, 126)
            .next()
            .map(|node| ExplicitGenericInvocationSuffixContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("ExplicitGenericInvocationContext", "explicitGenericInvocationSuffix"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExplicitGenericInvocationContext<'a, ValidatedTreeContext> {
    pub fn non_wildcard_type_arguments(&self) -> NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 120).next() else {
            unreachable!("validated ExplicitGenericInvocationContext is missing required child nonWildcardTypeArguments")
        };
        NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn explicit_generic_invocation_suffix(&self) -> ExplicitGenericInvocationSuffixContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 126).next() else {
            unreachable!("validated ExplicitGenericInvocationContext is missing required child explicitGenericInvocationSuffix")
        };
        ExplicitGenericInvocationSuffixContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeArgumentsOrDiamondContext {
        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> TypeArgumentsOrDiamondContext<'a, State> {
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeArgumentsOrDiamondContext<'a, ValidatedTreeContext> {
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NonWildcardTypeArgumentsOrDiamondContext {
        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> NonWildcardTypeArgumentsOrDiamondContext<'a, State> {
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NonWildcardTypeArgumentsOrDiamondContext<'a, ValidatedTreeContext> {
    pub fn non_wildcard_type_arguments(&self) -> Option<NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 120)
            .next()
            .map(|node| NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn gt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
    }
    pub fn lt_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct NonWildcardTypeArgumentsContext {
        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> NonWildcardTypeArgumentsContext<'a, State> {
    pub fn type_list(&self) -> Result<TypeListContext<'a>, MissingChildError> {
        __rule_children(self.__node, 121)
            .next()
            .map(|node| TypeListContext::__from_child_node(node, self.__invocation_states.as_deref()))
            .ok_or_else(|| MissingChildError::new("NonWildcardTypeArgumentsContext", "typeList"))
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NonWildcardTypeArgumentsContext", "GT"))
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("NonWildcardTypeArgumentsContext", "LT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> NonWildcardTypeArgumentsContext<'a, ValidatedTreeContext> {
    pub fn type_list(&self) -> TypeListContext<'a, ValidatedTreeContext> {
        let Some(node) = __rule_children(self.__node, 121).next() else {
            unreachable!("validated NonWildcardTypeArgumentsContext is missing required child typeList")
        };
        TypeListContext::<ValidatedTreeContext>::__from_validated_child_node(
            node,
            self.__invocation_states.as_deref(),
        )
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 89).next() else {
            unreachable!("validated NonWildcardTypeArgumentsContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 90).next() else {
            unreachable!("validated NonWildcardTypeArgumentsContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeListContext {
        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> TypeListContext<'a, State> {
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeListContext<'a, ValidatedTreeContext> {
    pub fn type_type_children(&self) -> impl Iterator<Item = TypeTypeContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 122)
            .map(move |node| TypeTypeContext::<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, 86).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeTypeContext {
        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> TypeTypeContext<'a, State> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_interface_type(&self) -> Option<ClassOrInterfaceTypeContext<'a>> {
        __rule_children(self.__node, 111)
            .next()
            .map(|node| ClassOrInterfaceTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primitive_type(&self) -> Option<PrimitiveTypeContext<'a>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| PrimitiveTypeContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeTypeContext<'a, ValidatedTreeContext> {
    pub fn annotation_children(&self) -> impl Iterator<Item = AnnotationContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 56)
            .map(move |node| AnnotationContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn class_or_interface_type(&self) -> Option<ClassOrInterfaceTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 111)
            .next()
            .map(|node| ClassOrInterfaceTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn primitive_type(&self) -> Option<PrimitiveTypeContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 123)
            .next()
            .map(|node| PrimitiveTypeContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 83).map(TerminalNode::new)
    }
    pub fn rbrack_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 84).map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct PrimitiveTypeContext {
        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> PrimitiveTypeContext<'a, State> {
    pub fn boolean_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 3)
            .next()
            .map(TerminalNode::new)
    }
    pub fn byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
    }
    pub fn char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 8)
            .next()
            .map(TerminalNode::new)
    }
    pub fn double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 21)
            .next()
            .map(TerminalNode::new)
    }
    pub fn int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 30)
            .next()
            .map(TerminalNode::new)
    }
    pub fn short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> PrimitiveTypeContext<'a, ValidatedTreeContext> {
    pub fn boolean_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 3)
            .next()
            .map(TerminalNode::new)
    }
    pub fn byte_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 5)
            .next()
            .map(TerminalNode::new)
    }
    pub fn char_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 8)
            .next()
            .map(TerminalNode::new)
    }
    pub fn double_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 14)
            .next()
            .map(TerminalNode::new)
    }
    pub fn float_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 21)
            .next()
            .map(TerminalNode::new)
    }
    pub fn int_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 28)
            .next()
            .map(TerminalNode::new)
    }
    pub fn long_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 30)
            .next()
            .map(TerminalNode::new)
    }
    pub fn short_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 47)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct TypeArgumentsContext {
        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> TypeArgumentsContext<'a, State> {
    pub fn type_argument_children(&self) -> impl Iterator<Item = TypeArgumentContext<'a>> + '_ {
        __rule_children(self.__node, 44)
            .map(move |node| TypeArgumentContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn comma_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
        __token_children(self.__node, 86).map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 89)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeArgumentsContext", "GT"))
    }
    pub fn lt_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 90)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("TypeArgumentsContext", "LT"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> TypeArgumentsContext<'a, ValidatedTreeContext> {
    pub fn type_argument_children(&self) -> impl Iterator<Item = TypeArgumentContext<'a, ValidatedTreeContext>> + '_ {
        __rule_children(self.__node, 44)
            .map(move |node| TypeArgumentContext::<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, 86).map(TerminalNode::new)
    }
    pub fn gt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 89).next() else {
            unreachable!("validated TypeArgumentsContext is missing required child GT")
        };
        TerminalNode::new(node)
    }
    pub fn lt_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 90).next() else {
            unreachable!("validated TypeArgumentsContext is missing required child LT")
        };
        TerminalNode::new(node)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct SuperSuffixContext {
        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> SuperSuffixContext<'a, State> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> SuperSuffixContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn type_arguments(&self) -> Option<TypeArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 124)
            .next()
            .map(|node| TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn dot_token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 87)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ExplicitGenericInvocationSuffixContext {
        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> ExplicitGenericInvocationSuffixContext<'a, State> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ExplicitGenericInvocationSuffixContext<'a, ValidatedTreeContext> {
    pub fn identifier(&self) -> Option<IdentifierContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 81)
            .next()
            .map(|node| IdentifierContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super_suffix(&self) -> Option<SuperSuffixContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 125)
            .next()
            .map(|node| SuperSuffixContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn arguments(&self) -> Option<ArgumentsContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 127)
            .next()
            .map(|node| ArgumentsContext::<ValidatedTreeContext>::__from_validated_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn super__token(&self) -> Option<TerminalNode<'a>> {
        __token_children(self.__node, 50)
            .next()
            .map(TerminalNode::new)
    }
}

antlr4_runtime::__antlr4_rust_context! {
    pub struct ArgumentsContext {
        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> ArgumentsContext<'a, State> {
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::__from_child_node(node, self.__invocation_states.as_deref()))
    }
    pub fn lparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 79)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArgumentsContext", "LPAREN"))
    }
    pub fn rparen_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
        __token_children(self.__node, 80)
            .next()
            .map(TerminalNode::new)
            .ok_or_else(|| MissingChildError::new("ArgumentsContext", "RPAREN"))
    }
}

#[allow(dead_code, clippy::all)]
impl<'a> ArgumentsContext<'a, ValidatedTreeContext> {
    pub fn expression_list(&self) -> Option<ExpressionListContext<'a, ValidatedTreeContext>> {
        __rule_children(self.__node, 96)
            .next()
            .map(|node| ExpressionListContext::<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, 79).next() else {
            unreachable!("validated ArgumentsContext is missing required child LPAREN")
        };
        TerminalNode::new(node)
    }
    pub fn rparen_token(&self) -> TerminalNode<'a> {
        let Some(node) = __token_children(self.__node, 80).next() else {
            unreachable!("validated ArgumentsContext is missing required child RPAREN")
        };
        TerminalNode::new(node)
    }
}

/// 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<(), JavaValidationError> {
    let tree = parsed.tree();
    if tree.as_rule().is_none() {
        return Err(JavaValidationError::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(JavaValidationError::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(JavaValidationError::MissingChild)?;
                },
                1 => {
                    let context = ModularCompulationUnitContext::__from_listener_node(context, None);
        let _ = context.module_declaration().map_err(JavaValidationError::MissingChild)?;
                },
                2 => {
                    let context = PackageDeclarationContext::__from_listener_node(context, None);
        let _ = context.qualified_name().map_err(JavaValidationError::MissingChild)?;
        let _ = context.package_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                3 => {
                    let context = ImportDeclarationContext::__from_listener_node(context, None);
        let _ = context.qualified_name().map_err(JavaValidationError::MissingChild)?;
        let _ = context.import_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                4 => {
                },
                5 => {
                },
                6 => {
                },
                7 => {
                },
                8 => {
                    let context = ClassDeclarationContext::__from_listener_node(context, None);
        let _ = context.class_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.class_token().map_err(JavaValidationError::MissingChild)?;
                },
                9 => {
                    let context = TypeParametersContext::__from_listener_node(context, None);
        {
            let actual = context.type_parameter_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "TypeParametersContext",
                    child: "typeParameter",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.gt_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lt_token().map_err(JavaValidationError::MissingChild)?;
                },
                10 => {
                    let context = TypeParameterContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
                },
                11 => {
                    let context = TypeBoundContext::__from_listener_node(context, None);
        {
            let actual = context.type_type_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "TypeBoundContext",
                    child: "typeType",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                12 => {
                    let context = EnumDeclarationContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.enum_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                13 => {
                    let context = EnumConstantsContext::__from_listener_node(context, None);
        {
            let actual = context.enum_constant_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "EnumConstantsContext",
                    child: "enumConstant",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                14 => {
                    let context = EnumConstantContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
                },
                15 => {
                    let context = EnumBodyDeclarationsContext::__from_listener_node(context, None);
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                16 => {
                    let context = InterfaceDeclarationContext::__from_listener_node(context, None);
        let _ = context.interface_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.interface_token().map_err(JavaValidationError::MissingChild)?;
                },
                17 => {
                    let context = ClassBodyContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                18 => {
                    let context = InterfaceBodyContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                19 => {
                },
                20 => {
                },
                21 => {
                    let context = MethodDeclarationContext::__from_listener_node(context, None);
        let _ = context.method_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.type_type_or_void().map_err(JavaValidationError::MissingChild)?;
        let _ = context.formal_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
                },
                22 => {
                },
                23 => {
                },
                24 => {
                    let context = GenericMethodDeclarationContext::__from_listener_node(context, None);
        let _ = context.type_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.method_declaration().map_err(JavaValidationError::MissingChild)?;
                },
                25 => {
                    let context = GenericConstructorDeclarationContext::__from_listener_node(context, None);
        let _ = context.type_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.constructor_declaration().map_err(JavaValidationError::MissingChild)?;
                },
                26 => {
                    let context = ConstructorDeclarationContext::__from_listener_node(context, None);
        let _ = context.formal_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.block().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.constructor_body().map_err(JavaValidationError::MissingChild)?;
                },
                27 => {
                    let context = CompactConstructorDeclarationContext::__from_listener_node(context, None);
        let _ = context.block().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.constructor_body().map_err(JavaValidationError::MissingChild)?;
                },
                28 => {
                    let context = FieldDeclarationContext::__from_listener_node(context, None);
        let _ = context.variable_declarators().map_err(JavaValidationError::MissingChild)?;
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                29 => {
                },
                30 => {
                },
                31 => {
                    let context = ConstDeclarationContext::__from_listener_node(context, None);
        {
            let actual = context.constant_declarator_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ConstDeclarationContext",
                    child: "constantDeclarator",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                32 => {
                    let context = ConstantDeclaratorContext::__from_listener_node(context, None);
        let _ = context.variable_initializer().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.assign_token().map_err(JavaValidationError::MissingChild)?;
                },
                33 => {
                    let context = InterfaceMethodDeclarationContext::__from_listener_node(context, None);
        let _ = context.interface_common_body_declaration().map_err(JavaValidationError::MissingChild)?;
                },
                34 => {
                },
                35 => {
                    let context = GenericInterfaceMethodDeclarationContext::__from_listener_node(context, None);
        let _ = context.type_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.interface_common_body_declaration().map_err(JavaValidationError::MissingChild)?;
                },
                36 => {
                    let context = InterfaceCommonBodyDeclarationContext::__from_listener_node(context, None);
        let _ = context.method_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.type_type_or_void().map_err(JavaValidationError::MissingChild)?;
        let _ = context.formal_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
                },
                37 => {
                    let context = VariableDeclaratorsContext::__from_listener_node(context, None);
        {
            let actual = context.variable_declarator_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "VariableDeclaratorsContext",
                    child: "variableDeclarator",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                38 => {
                    let context = VariableDeclaratorContext::__from_listener_node(context, None);
        let _ = context.variable_declarator_id().map_err(JavaValidationError::MissingChild)?;
                },
                39 => {
                    let context = VariableDeclaratorIdContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
                },
                40 => {
                },
                41 => {
                    let context = ArrayInitializerContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                42 => {
                    let context = ClassTypeContext::__from_listener_node(context, None);
        {
            let actual = context.type_identifier_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ClassTypeContext",
                    child: "typeIdentifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                43 => {
                    let context = PackageNameContext::__from_listener_node(context, None);
        {
            let actual = context.identifier_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "PackageNameContext",
                    child: "identifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                44 => {
                },
                45 => {
                    let context = QualifiedNameListContext::__from_listener_node(context, None);
        {
            let actual = context.qualified_name_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "QualifiedNameListContext",
                    child: "qualifiedName",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                46 => {
                    let context = FormalParametersContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                47 => {
                    let context = ReceiverParameterContext::__from_listener_node(context, None);
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
        let _ = context.this_token().map_err(JavaValidationError::MissingChild)?;
                },
                48 => {
                    let context = FormalParameterListContext::__from_listener_node(context, None);
        {
            let actual = context.formal_parameter_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "FormalParameterListContext",
                    child: "formalParameter",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                49 => {
                    let context = FormalParameterContext::__from_listener_node(context, None);
        let _ = context.variable_declarator_id().map_err(JavaValidationError::MissingChild)?;
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
                },
                50 => {
                    let context = LambdaLvtiListContext::__from_listener_node(context, None);
        {
            let actual = context.lambda_lvti_parameter_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "LambdaLvtiListContext",
                    child: "lambdaLVTIParameter",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                51 => {
                    let context = LambdaLvtiParameterContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.var_token().map_err(JavaValidationError::MissingChild)?;
                },
                52 => {
                    let context = QualifiedNameContext::__from_listener_node(context, None);
        {
            let actual = context.identifier_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "QualifiedNameContext",
                    child: "identifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                53 => {
                },
                54 => {
                },
                55 => {
                },
                56 => {
                    let context = AnnotationContext::__from_listener_node(context, None);
        let _ = context.qualified_name().map_err(JavaValidationError::MissingChild)?;
        let _ = context.at_token().map_err(JavaValidationError::MissingChild)?;
                },
                57 => {
                    let context = AnnotationFieldValuesContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                58 => {
                    let context = AnnotationFieldValueContext::__from_listener_node(context, None);
        let _ = context.annotation_value().map_err(JavaValidationError::MissingChild)?;
                },
                59 => {
                },
                60 => {
                },
                61 => {
                    let context = ElementValueArrayInitializerContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                62 => {
                    let context = AnnotationTypeDeclarationContext::__from_listener_node(context, None);
        let _ = context.annotation_type_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.interface_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.at_token().map_err(JavaValidationError::MissingChild)?;
                },
                63 => {
                    let context = AnnotationTypeBodyContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                64 => {
                },
                65 => {
                },
                66 => {
                },
                67 => {
                    let context = AnnotationMethodRestContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                68 => {
                    let context = AnnotationConstantRestContext::__from_listener_node(context, None);
        let _ = context.variable_declarators().map_err(JavaValidationError::MissingChild)?;
                },
                69 => {
                    let context = DefaultValueContext::__from_listener_node(context, None);
        let _ = context.element_value().map_err(JavaValidationError::MissingChild)?;
        let _ = context.default_token().map_err(JavaValidationError::MissingChild)?;
                },
                70 => {
                    let context = ModuleDeclarationContext::__from_listener_node(context, None);
        let _ = context.qualified_name().map_err(JavaValidationError::MissingChild)?;
        let _ = context.module_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                71 => {
                    let context = ModuleDirectiveContext::__from_listener_node(context, None);
        {
            let actual = context.qualified_name_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ModuleDirectiveContext",
                    child: "qualifiedName",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.semi_token().map_err(JavaValidationError::MissingChild)?;
                },
                72 => {
                },
                73 => {
                    let context = RecordDeclarationContext::__from_listener_node(context, None);
        let _ = context.record_header().map_err(JavaValidationError::MissingChild)?;
        let _ = context.record_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.record_token().map_err(JavaValidationError::MissingChild)?;
                },
                74 => {
                    let context = RecordHeaderContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                75 => {
                    let context = RecordComponentListContext::__from_listener_node(context, None);
        {
            let actual = context.record_component_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "RecordComponentListContext",
                    child: "recordComponent",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                76 => {
                    let context = RecordComponentContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
                },
                77 => {
                    let context = RecordBodyContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                78 => {
                    let context = BlockContext::__from_listener_node(context, None);
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                79 => {
                },
                80 => {
                },
                81 => {
                },
                82 => {
                },
                83 => {
                },
                84 => {
                },
                85 => {
                    let context = CatchClauseContext::__from_listener_node(context, None);
        let _ = context.block().map_err(JavaValidationError::MissingChild)?;
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.catch_type().map_err(JavaValidationError::MissingChild)?;
        let _ = context.catch_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                86 => {
                    let context = CatchTypeContext::__from_listener_node(context, None);
        {
            let actual = context.qualified_name_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "CatchTypeContext",
                    child: "qualifiedName",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                87 => {
                    let context = FinallyBlockContext::__from_listener_node(context, None);
        let _ = context.block().map_err(JavaValidationError::MissingChild)?;
        let _ = context.finally_token().map_err(JavaValidationError::MissingChild)?;
                },
                88 => {
                    let context = ResourceSpecificationContext::__from_listener_node(context, None);
        let _ = context.resources().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                89 => {
                    let context = ResourcesContext::__from_listener_node(context, None);
        {
            let actual = context.resource_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ResourcesContext",
                    child: "resource",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                90 => {
                },
                91 => {
                    let context = SwitchBlockStatementGroupContext::__from_listener_node(context, None);
        {
            let actual = context.block_statement_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "SwitchBlockStatementGroupContext",
                    child: "blockStatement",
                    minimum: 1,
                    actual,
                });
            }
        }
        {
            let actual = context.switch_label_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "SwitchBlockStatementGroupContext",
                    child: "switchLabel",
                    minimum: 1,
                    actual,
                });
            }
        }
        {
            let actual = context.colon_tokens().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "SwitchBlockStatementGroupContext",
                    child: "COLON",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                92 => {
                },
                93 => {
                },
                94 => {
                },
                95 => {
                    let context = EnhancedForControlContext::__from_listener_node(context, None);
        let _ = context.variable_declarator_id().map_err(JavaValidationError::MissingChild)?;
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(JavaValidationError::MissingChild)?;
                },
                96 => {
                    let context = ExpressionListContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ExpressionListContext",
                    child: "expression",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                97 => {
                    let context = MethodCallContext::__from_listener_node(context, None);
        let _ = context.arguments().map_err(JavaValidationError::MissingChild)?;
                },
                98 => {
                },
                99 => {
                    let context = PrimaryExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.primary().map_err(JavaValidationError::MissingChild)?;
                },
                100 => {
                    let context = SquareBracketExpressionLabelContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 2 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "SquareBracketExpressionLabelContext",
                    child: "expression",
                    minimum: 2,
                    actual,
                });
            }
        }
        let _ = context.lbrack_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrack_token().map_err(JavaValidationError::MissingChild)?;
                },
                101 => {
                    let context = MemberReferenceExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.dot_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.bop().map_err(JavaValidationError::MissingChild)?;
                },
                102 => {
                    let context = MethodCallExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.method_call().map_err(JavaValidationError::MissingChild)?;
                },
                103 => {
                    let context = MethodReferenceExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.coloncolon_token().map_err(JavaValidationError::MissingChild)?;
                },
                104 => {
                    let context = ExpressionSwitchLabelContext::__from_listener_node(context, None);
        let _ = context.switch_expression().map_err(JavaValidationError::MissingChild)?;
                },
                105 => {
                    let context = PostIncrementDecrementOperatorExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.postfix().map_err(JavaValidationError::MissingChild)?;
                },
                106 => {
                    let context = UnaryOperatorExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.prefix().map_err(JavaValidationError::MissingChild)?;
                },
                107 => {
                    let context = CastExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        {
            let actual = context.type_type_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "CastExpressionLabelContext",
                    child: "typeType",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                108 => {
                    let context = ObjectCreationExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.creator().map_err(JavaValidationError::MissingChild)?;
        let _ = context.new_token().map_err(JavaValidationError::MissingChild)?;
                },
                109 => {
                    let context = BinaryOperatorExpressionLabelContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 2 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "BinaryOperatorExpressionLabelContext",
                    child: "expression",
                    minimum: 2,
                    actual,
                });
            }
        }
                },
                110 => {
                    let context = InstanceOfOperatorExpressionLabelContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.instanceof_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.bop().map_err(JavaValidationError::MissingChild)?;
                },
                111 => {
                    let context = TernaryExpressionLabelContext::__from_listener_node(context, None);
        {
            let actual = context.expression_children().count();
            if actual < 3 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "TernaryExpressionLabelContext",
                    child: "expression",
                    minimum: 3,
                    actual,
                });
            }
        }
        let _ = context.question_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.bop().map_err(JavaValidationError::MissingChild)?;
                },
                112 => {
                    let context = ExpressionLambdaLabelContext::__from_listener_node(context, None);
        let _ = context.lambda_expression().map_err(JavaValidationError::MissingChild)?;
                },
                113 => {
                    let context = PatternContext::__from_listener_node(context, None);
        let _ = context.type_type().map_err(JavaValidationError::MissingChild)?;
                },
                114 => {
                    let context = ComponentPatternListContext::__from_listener_node(context, None);
        {
            let actual = context.component_pattern_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ComponentPatternListContext",
                    child: "componentPattern",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                115 => {
                    let context = ComponentPatternContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(JavaValidationError::MissingChild)?;
                },
                116 => {
                    let context = LambdaExpressionContext::__from_listener_node(context, None);
        let _ = context.lambda_parameters().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lambda_body().map_err(JavaValidationError::MissingChild)?;
        let _ = context.arrow_token().map_err(JavaValidationError::MissingChild)?;
                },
                117 => {
                },
                118 => {
                },
                119 => {
                },
                120 => {
                    let context = SwitchExpressionContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.switch_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lbrace_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(JavaValidationError::MissingChild)?;
                },
                121 => {
                    let context = SwitchLabeledRuleContext::__from_listener_node(context, None);
        let _ = context.switch_rule_outcome().map_err(JavaValidationError::MissingChild)?;
                },
                122 => {
                    let context = GuardContext::__from_listener_node(context, None);
        let _ = context.expression().map_err(JavaValidationError::MissingChild)?;
        let _ = context.when_token().map_err(JavaValidationError::MissingChild)?;
                },
                123 => {
                    let context = CasePatternContext::__from_listener_node(context, None);
        let _ = context.pattern().map_err(JavaValidationError::MissingChild)?;
                },
                124 => {
                },
                125 => {
                    let context = ClassOrInterfaceTypeContext::__from_listener_node(context, None);
        let _ = context.class_type().map_err(JavaValidationError::MissingChild)?;
                },
                126 => {
                    let context = CreatorContext::__from_listener_node(context, None);
        let _ = context.created_name().map_err(JavaValidationError::MissingChild)?;
                },
                127 => {
                },
                128 => {
                    let context = InnerCreatorContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(JavaValidationError::MissingChild)?;
        let _ = context.class_creator_rest().map_err(JavaValidationError::MissingChild)?;
                },
                129 => {
                    let context = ArrayCreatorRestContext::__from_listener_node(context, None);
        {
            let actual = context.lbrack_tokens().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ArrayCreatorRestContext",
                    child: "LBRACK",
                    minimum: 1,
                    actual,
                });
            }
        }
        {
            let actual = context.rbrack_tokens().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "ArrayCreatorRestContext",
                    child: "RBRACK",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                130 => {
                    let context = ClassCreatorRestContext::__from_listener_node(context, None);
        let _ = context.arguments().map_err(JavaValidationError::MissingChild)?;
                },
                131 => {
                    let context = ExplicitGenericInvocationContext::__from_listener_node(context, None);
        let _ = context.non_wildcard_type_arguments().map_err(JavaValidationError::MissingChild)?;
        let _ = context.explicit_generic_invocation_suffix().map_err(JavaValidationError::MissingChild)?;
                },
                132 => {
                },
                133 => {
                },
                134 => {
                    let context = NonWildcardTypeArgumentsContext::__from_listener_node(context, None);
        let _ = context.type_list().map_err(JavaValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lt_token().map_err(JavaValidationError::MissingChild)?;
                },
                135 => {
                    let context = TypeListContext::__from_listener_node(context, None);
        {
            let actual = context.type_type_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "TypeListContext",
                    child: "typeType",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                136 => {
                },
                137 => {
                },
                138 => {
                    let context = TypeArgumentsContext::__from_listener_node(context, None);
        {
            let actual = context.type_argument_children().count();
            if actual < 1 {
                return Err(JavaValidationError::InvalidChildCount {
                    context: "TypeArgumentsContext",
                    child: "typeArgument",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.gt_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.lt_token().map_err(JavaValidationError::MissingChild)?;
                },
                139 => {
                },
                140 => {
                },
                141 => {
                    let context = ArgumentsContext::__from_listener_node(context, None);
        let _ = context.lparen_token().map_err(JavaValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(JavaValidationError::MissingChild)?;
                },
                    _ => {
                        return Err(JavaValidationError::UnknownRule {
                            rule_index: context.rule_index(),
                        });
                    }
                }
            }
        }
    }
    Ok(())
}

#[allow(dead_code, unused_variables)]
pub trait JavaListener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: antlr4_runtime::Node<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        JavaTreeWalker::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_modular_compulation_unit(&mut self, _ctx: &ModularCompulationUnitContext) -> Result<(), E> { Ok(()) }
    fn exit_modular_compulation_unit(&mut self, _ctx: &ModularCompulationUnitContext) -> Result<(), E> { Ok(()) }
    fn enter_package_declaration(&mut self, _ctx: &PackageDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_package_declaration(&mut self, _ctx: &PackageDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_import_declaration(&mut self, _ctx: &ImportDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_import_declaration(&mut self, _ctx: &ImportDeclarationContext) -> 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_modifier(&mut self, _ctx: &ModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_modifier(&mut self, _ctx: &ModifierContext) -> Result<(), E> { Ok(()) }
    fn enter_class_or_interface_modifier(&mut self, _ctx: &ClassOrInterfaceModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_class_or_interface_modifier(&mut self, _ctx: &ClassOrInterfaceModifierContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_modifier(&mut self, _ctx: &VariableModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_modifier(&mut self, _ctx: &VariableModifierContext) -> 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_type_parameters(&mut self, _ctx: &TypeParametersContext) -> Result<(), E> { Ok(()) }
    fn exit_type_parameters(&mut self, _ctx: &TypeParametersContext) -> 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_bound(&mut self, _ctx: &TypeBoundContext) -> Result<(), E> { Ok(()) }
    fn exit_type_bound(&mut self, _ctx: &TypeBoundContext) -> 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_enum_constants(&mut self, _ctx: &EnumConstantsContext) -> Result<(), E> { Ok(()) }
    fn exit_enum_constants(&mut self, _ctx: &EnumConstantsContext) -> Result<(), E> { Ok(()) }
    fn enter_enum_constant(&mut self, _ctx: &EnumConstantContext) -> Result<(), E> { Ok(()) }
    fn exit_enum_constant(&mut self, _ctx: &EnumConstantContext) -> Result<(), E> { Ok(()) }
    fn enter_enum_body_declarations(&mut self, _ctx: &EnumBodyDeclarationsContext) -> Result<(), E> { Ok(()) }
    fn exit_enum_body_declarations(&mut self, _ctx: &EnumBodyDeclarationsContext) -> 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_class_body(&mut self, _ctx: &ClassBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_class_body(&mut self, _ctx: &ClassBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_body(&mut self, _ctx: &InterfaceBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_body(&mut self, _ctx: &InterfaceBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_class_body_declaration(&mut self, _ctx: &ClassBodyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_class_body_declaration(&mut self, _ctx: &ClassBodyDeclarationContext) -> 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_method_declaration(&mut self, _ctx: &MethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_method_declaration(&mut self, _ctx: &MethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_method_body(&mut self, _ctx: &MethodBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_method_body(&mut self, _ctx: &MethodBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_type_type_or_void(&mut self, _ctx: &TypeTypeOrVoidContext) -> Result<(), E> { Ok(()) }
    fn exit_type_type_or_void(&mut self, _ctx: &TypeTypeOrVoidContext) -> Result<(), E> { Ok(()) }
    fn enter_generic_method_declaration(&mut self, _ctx: &GenericMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_generic_method_declaration(&mut self, _ctx: &GenericMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_generic_constructor_declaration(&mut self, _ctx: &GenericConstructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_generic_constructor_declaration(&mut self, _ctx: &GenericConstructorDeclarationContext) -> 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_compact_constructor_declaration(&mut self, _ctx: &CompactConstructorDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_compact_constructor_declaration(&mut self, _ctx: &CompactConstructorDeclarationContext) -> 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_interface_body_declaration(&mut self, _ctx: &InterfaceBodyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_body_declaration(&mut self, _ctx: &InterfaceBodyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_member_declaration(&mut self, _ctx: &InterfaceMemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_member_declaration(&mut self, _ctx: &InterfaceMemberDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_const_declaration(&mut self, _ctx: &ConstDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_const_declaration(&mut self, _ctx: &ConstDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_constant_declarator(&mut self, _ctx: &ConstantDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn exit_constant_declarator(&mut self, _ctx: &ConstantDeclaratorContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_method_declaration(&mut self, _ctx: &InterfaceMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_method_declaration(&mut self, _ctx: &InterfaceMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_method_modifier(&mut self, _ctx: &InterfaceMethodModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_method_modifier(&mut self, _ctx: &InterfaceMethodModifierContext) -> Result<(), E> { Ok(()) }
    fn enter_generic_interface_method_declaration(&mut self, _ctx: &GenericInterfaceMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_generic_interface_method_declaration(&mut self, _ctx: &GenericInterfaceMethodDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_interface_common_body_declaration(&mut self, _ctx: &InterfaceCommonBodyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_interface_common_body_declaration(&mut self, _ctx: &InterfaceCommonBodyDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_declarators(&mut self, _ctx: &VariableDeclaratorsContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarators(&mut self, _ctx: &VariableDeclaratorsContext) -> 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_variable_declarator_id(&mut self, _ctx: &VariableDeclaratorIdContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarator_id(&mut self, _ctx: &VariableDeclaratorIdContext) -> Result<(), E> { Ok(()) }
    fn enter_variable_initializer(&mut self, _ctx: &VariableInitializerContext) -> Result<(), E> { Ok(()) }
    fn exit_variable_initializer(&mut self, _ctx: &VariableInitializerContext) -> Result<(), E> { Ok(()) }
    fn enter_array_initializer(&mut self, _ctx: &ArrayInitializerContext) -> Result<(), E> { Ok(()) }
    fn exit_array_initializer(&mut self, _ctx: &ArrayInitializerContext) -> Result<(), E> { Ok(()) }
    fn enter_class_type(&mut self, _ctx: &ClassTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_class_type(&mut self, _ctx: &ClassTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_package_name(&mut self, _ctx: &PackageNameContext) -> Result<(), E> { Ok(()) }
    fn exit_package_name(&mut self, _ctx: &PackageNameContext) -> Result<(), E> { Ok(()) }
    fn enter_type_argument(&mut self, _ctx: &TypeArgumentContext) -> Result<(), E> { Ok(()) }
    fn exit_type_argument(&mut self, _ctx: &TypeArgumentContext) -> Result<(), E> { Ok(()) }
    fn enter_qualified_name_list(&mut self, _ctx: &QualifiedNameListContext) -> Result<(), E> { Ok(()) }
    fn exit_qualified_name_list(&mut self, _ctx: &QualifiedNameListContext) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameters(&mut self, _ctx: &FormalParametersContext) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameters(&mut self, _ctx: &FormalParametersContext) -> Result<(), E> { Ok(()) }
    fn enter_receiver_parameter(&mut self, _ctx: &ReceiverParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_receiver_parameter(&mut self, _ctx: &ReceiverParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameter_list(&mut self, _ctx: &FormalParameterListContext) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameter_list(&mut self, _ctx: &FormalParameterListContext) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameter(&mut self, _ctx: &FormalParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameter(&mut self, _ctx: &FormalParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_lambda_lvti_list(&mut self, _ctx: &LambdaLvtiListContext) -> Result<(), E> { Ok(()) }
    fn exit_lambda_lvti_list(&mut self, _ctx: &LambdaLvtiListContext) -> Result<(), E> { Ok(()) }
    fn enter_lambda_lvti_parameter(&mut self, _ctx: &LambdaLvtiParameterContext) -> Result<(), E> { Ok(()) }
    fn exit_lambda_lvti_parameter(&mut self, _ctx: &LambdaLvtiParameterContext) -> Result<(), E> { Ok(()) }
    fn enter_qualified_name(&mut self, _ctx: &QualifiedNameContext) -> Result<(), E> { Ok(()) }
    fn exit_qualified_name(&mut self, _ctx: &QualifiedNameContext) -> Result<(), E> { Ok(()) }
    fn enter_literal(&mut self, _ctx: &LiteralContext) -> Result<(), E> { Ok(()) }
    fn exit_literal(&mut self, _ctx: &LiteralContext) -> Result<(), E> { Ok(()) }
    fn enter_integer_literal(&mut self, _ctx: &IntegerLiteralContext) -> Result<(), E> { Ok(()) }
    fn exit_integer_literal(&mut self, _ctx: &IntegerLiteralContext) -> Result<(), E> { Ok(()) }
    fn enter_float_literal(&mut self, _ctx: &FloatLiteralContext) -> Result<(), E> { Ok(()) }
    fn exit_float_literal(&mut self, _ctx: &FloatLiteralContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation(&mut self, _ctx: &AnnotationContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation(&mut self, _ctx: &AnnotationContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_field_values(&mut self, _ctx: &AnnotationFieldValuesContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_field_values(&mut self, _ctx: &AnnotationFieldValuesContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_field_value(&mut self, _ctx: &AnnotationFieldValueContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_field_value(&mut self, _ctx: &AnnotationFieldValueContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_value(&mut self, _ctx: &AnnotationValueContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_value(&mut self, _ctx: &AnnotationValueContext) -> Result<(), E> { Ok(()) }
    fn enter_element_value(&mut self, _ctx: &ElementValueContext) -> Result<(), E> { Ok(()) }
    fn exit_element_value(&mut self, _ctx: &ElementValueContext) -> Result<(), E> { Ok(()) }
    fn enter_element_value_array_initializer(&mut self, _ctx: &ElementValueArrayInitializerContext) -> Result<(), E> { Ok(()) }
    fn exit_element_value_array_initializer(&mut self, _ctx: &ElementValueArrayInitializerContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_declaration(&mut self, _ctx: &AnnotationTypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_declaration(&mut self, _ctx: &AnnotationTypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_body(&mut self, _ctx: &AnnotationTypeBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_body(&mut self, _ctx: &AnnotationTypeBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_element_declaration(&mut self, _ctx: &AnnotationTypeElementDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_element_declaration(&mut self, _ctx: &AnnotationTypeElementDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_element_rest(&mut self, _ctx: &AnnotationTypeElementRestContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_element_rest(&mut self, _ctx: &AnnotationTypeElementRestContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_method_or_constant_rest(&mut self, _ctx: &AnnotationMethodOrConstantRestContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_method_or_constant_rest(&mut self, _ctx: &AnnotationMethodOrConstantRestContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_method_rest(&mut self, _ctx: &AnnotationMethodRestContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_method_rest(&mut self, _ctx: &AnnotationMethodRestContext) -> Result<(), E> { Ok(()) }
    fn enter_annotation_constant_rest(&mut self, _ctx: &AnnotationConstantRestContext) -> Result<(), E> { Ok(()) }
    fn exit_annotation_constant_rest(&mut self, _ctx: &AnnotationConstantRestContext) -> Result<(), E> { Ok(()) }
    fn enter_default_value(&mut self, _ctx: &DefaultValueContext) -> Result<(), E> { Ok(()) }
    fn exit_default_value(&mut self, _ctx: &DefaultValueContext) -> Result<(), E> { Ok(()) }
    fn enter_module_declaration(&mut self, _ctx: &ModuleDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_module_declaration(&mut self, _ctx: &ModuleDeclarationContext) -> Result<(), E> { Ok(()) }
    fn enter_module_directive(&mut self, _ctx: &ModuleDirectiveContext) -> Result<(), E> { Ok(()) }
    fn exit_module_directive(&mut self, _ctx: &ModuleDirectiveContext) -> Result<(), E> { Ok(()) }
    fn enter_requires_modifier(&mut self, _ctx: &RequiresModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_requires_modifier(&mut self, _ctx: &RequiresModifierContext) -> 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_record_header(&mut self, _ctx: &RecordHeaderContext) -> Result<(), E> { Ok(()) }
    fn exit_record_header(&mut self, _ctx: &RecordHeaderContext) -> Result<(), E> { Ok(()) }
    fn enter_record_component_list(&mut self, _ctx: &RecordComponentListContext) -> Result<(), E> { Ok(()) }
    fn exit_record_component_list(&mut self, _ctx: &RecordComponentListContext) -> Result<(), E> { Ok(()) }
    fn enter_record_component(&mut self, _ctx: &RecordComponentContext) -> Result<(), E> { Ok(()) }
    fn exit_record_component(&mut self, _ctx: &RecordComponentContext) -> Result<(), E> { Ok(()) }
    fn enter_record_body(&mut self, _ctx: &RecordBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_record_body(&mut self, _ctx: &RecordBodyContext) -> 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_block_statement(&mut self, _ctx: &BlockStatementContext) -> Result<(), E> { Ok(()) }
    fn exit_block_statement(&mut self, _ctx: &BlockStatementContext) -> 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_identifier(&mut self, _ctx: &IdentifierContext) -> Result<(), E> { Ok(()) }
    fn exit_identifier(&mut self, _ctx: &IdentifierContext) -> Result<(), E> { Ok(()) }
    fn enter_type_identifier(&mut self, _ctx: &TypeIdentifierContext) -> Result<(), E> { Ok(()) }
    fn exit_type_identifier(&mut self, _ctx: &TypeIdentifierContext) -> Result<(), E> { Ok(()) }
    fn enter_local_type_declaration(&mut self, _ctx: &LocalTypeDeclarationContext) -> Result<(), E> { Ok(()) }
    fn exit_local_type_declaration(&mut self, _ctx: &LocalTypeDeclarationContext) -> 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_catch_clause(&mut self, _ctx: &CatchClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_catch_clause(&mut self, _ctx: &CatchClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_catch_type(&mut self, _ctx: &CatchTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_catch_type(&mut self, _ctx: &CatchTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_finally_block(&mut self, _ctx: &FinallyBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_finally_block(&mut self, _ctx: &FinallyBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_resource_specification(&mut self, _ctx: &ResourceSpecificationContext) -> Result<(), E> { Ok(()) }
    fn exit_resource_specification(&mut self, _ctx: &ResourceSpecificationContext) -> Result<(), E> { Ok(()) }
    fn enter_resources(&mut self, _ctx: &ResourcesContext) -> Result<(), E> { Ok(()) }
    fn exit_resources(&mut self, _ctx: &ResourcesContext) -> Result<(), E> { Ok(()) }
    fn enter_resource(&mut self, _ctx: &ResourceContext) -> Result<(), E> { Ok(()) }
    fn exit_resource(&mut self, _ctx: &ResourceContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_block_statement_group(&mut self, _ctx: &SwitchBlockStatementGroupContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_block_statement_group(&mut self, _ctx: &SwitchBlockStatementGroupContext) -> 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_for_control(&mut self, _ctx: &ForControlContext) -> Result<(), E> { Ok(()) }
    fn exit_for_control(&mut self, _ctx: &ForControlContext) -> Result<(), E> { Ok(()) }
    fn enter_for_init(&mut self, _ctx: &ForInitContext) -> Result<(), E> { Ok(()) }
    fn exit_for_init(&mut self, _ctx: &ForInitContext) -> Result<(), E> { Ok(()) }
    fn enter_enhanced_for_control(&mut self, _ctx: &EnhancedForControlContext) -> Result<(), E> { Ok(()) }
    fn exit_enhanced_for_control(&mut self, _ctx: &EnhancedForControlContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_list(&mut self, _ctx: &ExpressionListContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_list(&mut self, _ctx: &ExpressionListContext) -> Result<(), E> { Ok(()) }
    fn enter_method_call(&mut self, _ctx: &MethodCallContext) -> Result<(), E> { Ok(()) }
    fn exit_method_call(&mut self, _ctx: &MethodCallContext) -> 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_primary_expression_label(&mut self, _ctx: &PrimaryExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_primary_expression_label(&mut self, _ctx: &PrimaryExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_square_bracket_expression_label(&mut self, _ctx: &SquareBracketExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_square_bracket_expression_label(&mut self, _ctx: &SquareBracketExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_member_reference_expression_label(&mut self, _ctx: &MemberReferenceExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_member_reference_expression_label(&mut self, _ctx: &MemberReferenceExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_method_call_expression_label(&mut self, _ctx: &MethodCallExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_method_call_expression_label(&mut self, _ctx: &MethodCallExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_method_reference_expression_label(&mut self, _ctx: &MethodReferenceExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_method_reference_expression_label(&mut self, _ctx: &MethodReferenceExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_switch_label(&mut self, _ctx: &ExpressionSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_switch_label(&mut self, _ctx: &ExpressionSwitchLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_post_increment_decrement_operator_expression_label(&mut self, _ctx: &PostIncrementDecrementOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_post_increment_decrement_operator_expression_label(&mut self, _ctx: &PostIncrementDecrementOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_unary_operator_expression_label(&mut self, _ctx: &UnaryOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_unary_operator_expression_label(&mut self, _ctx: &UnaryOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_cast_expression_label(&mut self, _ctx: &CastExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_cast_expression_label(&mut self, _ctx: &CastExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_object_creation_expression_label(&mut self, _ctx: &ObjectCreationExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_object_creation_expression_label(&mut self, _ctx: &ObjectCreationExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_binary_operator_expression_label(&mut self, _ctx: &BinaryOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_binary_operator_expression_label(&mut self, _ctx: &BinaryOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_instance_of_operator_expression_label(&mut self, _ctx: &InstanceOfOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_instance_of_operator_expression_label(&mut self, _ctx: &InstanceOfOperatorExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_ternary_expression_label(&mut self, _ctx: &TernaryExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_ternary_expression_label(&mut self, _ctx: &TernaryExpressionLabelContext) -> Result<(), E> { Ok(()) }
    fn enter_expression_lambda_label(&mut self, _ctx: &ExpressionLambdaLabelContext) -> Result<(), E> { Ok(()) }
    fn exit_expression_lambda_label(&mut self, _ctx: &ExpressionLambdaLabelContext) -> 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_component_pattern_list(&mut self, _ctx: &ComponentPatternListContext) -> Result<(), E> { Ok(()) }
    fn exit_component_pattern_list(&mut self, _ctx: &ComponentPatternListContext) -> Result<(), E> { Ok(()) }
    fn enter_component_pattern(&mut self, _ctx: &ComponentPatternContext) -> Result<(), E> { Ok(()) }
    fn exit_component_pattern(&mut self, _ctx: &ComponentPatternContext) -> 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_lambda_parameters(&mut self, _ctx: &LambdaParametersContext) -> Result<(), E> { Ok(()) }
    fn exit_lambda_parameters(&mut self, _ctx: &LambdaParametersContext) -> Result<(), E> { Ok(()) }
    fn enter_lambda_body(&mut self, _ctx: &LambdaBodyContext) -> Result<(), E> { Ok(()) }
    fn exit_lambda_body(&mut self, _ctx: &LambdaBodyContext) -> Result<(), E> { Ok(()) }
    fn enter_primary(&mut self, _ctx: &PrimaryContext) -> Result<(), E> { Ok(()) }
    fn exit_primary(&mut self, _ctx: &PrimaryContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_expression(&mut self, _ctx: &SwitchExpressionContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_expression(&mut self, _ctx: &SwitchExpressionContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_labeled_rule(&mut self, _ctx: &SwitchLabeledRuleContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_labeled_rule(&mut self, _ctx: &SwitchLabeledRuleContext) -> Result<(), E> { Ok(()) }
    fn enter_guard(&mut self, _ctx: &GuardContext) -> Result<(), E> { Ok(()) }
    fn exit_guard(&mut self, _ctx: &GuardContext) -> Result<(), E> { Ok(()) }
    fn enter_case_pattern(&mut self, _ctx: &CasePatternContext) -> Result<(), E> { Ok(()) }
    fn exit_case_pattern(&mut self, _ctx: &CasePatternContext) -> Result<(), E> { Ok(()) }
    fn enter_switch_rule_outcome(&mut self, _ctx: &SwitchRuleOutcomeContext) -> Result<(), E> { Ok(()) }
    fn exit_switch_rule_outcome(&mut self, _ctx: &SwitchRuleOutcomeContext) -> Result<(), E> { Ok(()) }
    fn enter_class_or_interface_type(&mut self, _ctx: &ClassOrInterfaceTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_class_or_interface_type(&mut self, _ctx: &ClassOrInterfaceTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_creator(&mut self, _ctx: &CreatorContext) -> Result<(), E> { Ok(()) }
    fn exit_creator(&mut self, _ctx: &CreatorContext) -> Result<(), E> { Ok(()) }
    fn enter_created_name(&mut self, _ctx: &CreatedNameContext) -> Result<(), E> { Ok(()) }
    fn exit_created_name(&mut self, _ctx: &CreatedNameContext) -> Result<(), E> { Ok(()) }
    fn enter_inner_creator(&mut self, _ctx: &InnerCreatorContext) -> Result<(), E> { Ok(()) }
    fn exit_inner_creator(&mut self, _ctx: &InnerCreatorContext) -> Result<(), E> { Ok(()) }
    fn enter_array_creator_rest(&mut self, _ctx: &ArrayCreatorRestContext) -> Result<(), E> { Ok(()) }
    fn exit_array_creator_rest(&mut self, _ctx: &ArrayCreatorRestContext) -> Result<(), E> { Ok(()) }
    fn enter_class_creator_rest(&mut self, _ctx: &ClassCreatorRestContext) -> Result<(), E> { Ok(()) }
    fn exit_class_creator_rest(&mut self, _ctx: &ClassCreatorRestContext) -> Result<(), E> { Ok(()) }
    fn enter_explicit_generic_invocation(&mut self, _ctx: &ExplicitGenericInvocationContext) -> Result<(), E> { Ok(()) }
    fn exit_explicit_generic_invocation(&mut self, _ctx: &ExplicitGenericInvocationContext) -> Result<(), E> { Ok(()) }
    fn enter_type_arguments_or_diamond(&mut self, _ctx: &TypeArgumentsOrDiamondContext) -> Result<(), E> { Ok(()) }
    fn exit_type_arguments_or_diamond(&mut self, _ctx: &TypeArgumentsOrDiamondContext) -> Result<(), E> { Ok(()) }
    fn enter_non_wildcard_type_arguments_or_diamond(&mut self, _ctx: &NonWildcardTypeArgumentsOrDiamondContext) -> Result<(), E> { Ok(()) }
    fn exit_non_wildcard_type_arguments_or_diamond(&mut self, _ctx: &NonWildcardTypeArgumentsOrDiamondContext) -> Result<(), E> { Ok(()) }
    fn enter_non_wildcard_type_arguments(&mut self, _ctx: &NonWildcardTypeArgumentsContext) -> Result<(), E> { Ok(()) }
    fn exit_non_wildcard_type_arguments(&mut self, _ctx: &NonWildcardTypeArgumentsContext) -> Result<(), E> { Ok(()) }
    fn enter_type_list(&mut self, _ctx: &TypeListContext) -> Result<(), E> { Ok(()) }
    fn exit_type_list(&mut self, _ctx: &TypeListContext) -> Result<(), E> { Ok(()) }
    fn enter_type_type(&mut self, _ctx: &TypeTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_type_type(&mut self, _ctx: &TypeTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_primitive_type(&mut self, _ctx: &PrimitiveTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_primitive_type(&mut self, _ctx: &PrimitiveTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_type_arguments(&mut self, _ctx: &TypeArgumentsContext) -> Result<(), E> { Ok(()) }
    fn exit_type_arguments(&mut self, _ctx: &TypeArgumentsContext) -> Result<(), E> { Ok(()) }
    fn enter_super_suffix(&mut self, _ctx: &SuperSuffixContext) -> Result<(), E> { Ok(()) }
    fn exit_super_suffix(&mut self, _ctx: &SuperSuffixContext) -> Result<(), E> { Ok(()) }
    fn enter_explicit_generic_invocation_suffix(&mut self, _ctx: &ExplicitGenericInvocationSuffixContext) -> Result<(), E> { Ok(()) }
    fn exit_explicit_generic_invocation_suffix(&mut self, _ctx: &ExplicitGenericInvocationSuffixContext) -> Result<(), E> { Ok(()) }
    fn enter_arguments(&mut self, _ctx: &ArgumentsContext) -> Result<(), E> { Ok(()) }
    fn exit_arguments(&mut self, _ctx: &ArgumentsContext) -> 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 JavaTreeWalker;

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

    pub fn walk_with_invocation_states<E, T: JavaListener<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: JavaListener<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_modular_compulation_unit(&ModularCompulationUnitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_package_declaration(&PackageDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_import_declaration(&ImportDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_type_declaration(&TypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_modifier(&ModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_class_or_interface_modifier(&ClassOrInterfaceModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_variable_modifier(&VariableModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_class_declaration(&ClassDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_type_parameters(&TypeParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_type_parameter(&TypeParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_type_bound(&TypeBoundContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_enum_declaration(&EnumDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_enum_constants(&EnumConstantsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_enum_constant(&EnumConstantContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_enum_body_declarations(&EnumBodyDeclarationsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_interface_declaration(&InterfaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_class_body(&ClassBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_interface_body(&InterfaceBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_class_body_declaration(&ClassBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_member_declaration(&MemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_method_declaration(&MethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_method_body(&MethodBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_type_type_or_void(&TypeTypeOrVoidContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_generic_method_declaration(&GenericMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_generic_constructor_declaration(&GenericConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_constructor_declaration(&ConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_compact_constructor_declaration(&CompactConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_field_declaration(&FieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_interface_body_declaration(&InterfaceBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_interface_member_declaration(&InterfaceMemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_const_declaration(&ConstDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_constant_declarator(&ConstantDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_interface_method_declaration(&InterfaceMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_interface_method_modifier(&InterfaceMethodModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_generic_interface_method_declaration(&GenericInterfaceMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_interface_common_body_declaration(&InterfaceCommonBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_variable_declarators(&VariableDeclaratorsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_variable_declarator(&VariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_variable_declarator_id(&VariableDeclaratorIdContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_variable_initializer(&VariableInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_array_initializer(&ArrayInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_class_type(&ClassTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_package_name(&PackageNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_type_argument(&TypeArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_qualified_name_list(&QualifiedNameListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_formal_parameters(&FormalParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_receiver_parameter(&ReceiverParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_formal_parameter_list(&FormalParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_formal_parameter(&FormalParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_lambda_lvti_list(&LambdaLvtiListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_lambda_lvti_parameter(&LambdaLvtiParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_qualified_name(&QualifiedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_literal(&LiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_integer_literal(&IntegerLiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_float_literal(&FloatLiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_annotation(&AnnotationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_annotation_field_values(&AnnotationFieldValuesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_annotation_field_value(&AnnotationFieldValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_annotation_value(&AnnotationValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_element_value(&ElementValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_element_value_array_initializer(&ElementValueArrayInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_annotation_type_declaration(&AnnotationTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_annotation_type_body(&AnnotationTypeBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_annotation_type_element_declaration(&AnnotationTypeElementDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_annotation_type_element_rest(&AnnotationTypeElementRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_annotation_method_or_constant_rest(&AnnotationMethodOrConstantRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        67 => listener.enter_annotation_method_rest(&AnnotationMethodRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        68 => listener.enter_annotation_constant_rest(&AnnotationConstantRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        69 => listener.enter_default_value(&DefaultValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        70 => listener.enter_module_declaration(&ModuleDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        71 => listener.enter_module_directive(&ModuleDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        72 => listener.enter_requires_modifier(&RequiresModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        73 => listener.enter_record_declaration(&RecordDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        74 => listener.enter_record_header(&RecordHeaderContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        75 => listener.enter_record_component_list(&RecordComponentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        76 => listener.enter_record_component(&RecordComponentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        77 => listener.enter_record_body(&RecordBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        78 => listener.enter_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        79 => listener.enter_block_statement(&BlockStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        80 => listener.enter_local_variable_declaration(&LocalVariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        81 => listener.enter_identifier(&IdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        82 => listener.enter_type_identifier(&TypeIdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        83 => listener.enter_local_type_declaration(&LocalTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        84 => listener.enter_statement(&StatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        85 => listener.enter_catch_clause(&CatchClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        86 => listener.enter_catch_type(&CatchTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        87 => listener.enter_finally_block(&FinallyBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        88 => listener.enter_resource_specification(&ResourceSpecificationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        89 => listener.enter_resources(&ResourcesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        90 => listener.enter_resource(&ResourceContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        91 => listener.enter_switch_block_statement_group(&SwitchBlockStatementGroupContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        92 => listener.enter_switch_label(&SwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        93 => listener.enter_for_control(&ForControlContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        94 => listener.enter_for_init(&ForInitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        95 => listener.enter_enhanced_for_control(&EnhancedForControlContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        96 => listener.enter_expression_list(&ExpressionListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        97 => listener.enter_method_call(&MethodCallContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        98 => listener.enter_expression(&ExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        99 => listener.enter_primary_expression_label(&PrimaryExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        100 => listener.enter_square_bracket_expression_label(&SquareBracketExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        101 => listener.enter_member_reference_expression_label(&MemberReferenceExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        102 => listener.enter_method_call_expression_label(&MethodCallExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        103 => listener.enter_method_reference_expression_label(&MethodReferenceExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        104 => listener.enter_expression_switch_label(&ExpressionSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        105 => listener.enter_post_increment_decrement_operator_expression_label(&PostIncrementDecrementOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        106 => listener.enter_unary_operator_expression_label(&UnaryOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        107 => listener.enter_cast_expression_label(&CastExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        108 => listener.enter_object_creation_expression_label(&ObjectCreationExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        109 => listener.enter_binary_operator_expression_label(&BinaryOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        110 => listener.enter_instance_of_operator_expression_label(&InstanceOfOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        111 => listener.enter_ternary_expression_label(&TernaryExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        112 => listener.enter_expression_lambda_label(&ExpressionLambdaLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        113 => listener.enter_pattern(&PatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        114 => listener.enter_component_pattern_list(&ComponentPatternListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        115 => listener.enter_component_pattern(&ComponentPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        116 => listener.enter_lambda_expression(&LambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        117 => listener.enter_lambda_parameters(&LambdaParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        118 => listener.enter_lambda_body(&LambdaBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        119 => listener.enter_primary(&PrimaryContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        120 => listener.enter_switch_expression(&SwitchExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        121 => listener.enter_switch_labeled_rule(&SwitchLabeledRuleContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        122 => listener.enter_guard(&GuardContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        123 => listener.enter_case_pattern(&CasePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        124 => listener.enter_switch_rule_outcome(&SwitchRuleOutcomeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        125 => listener.enter_class_or_interface_type(&ClassOrInterfaceTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        126 => listener.enter_creator(&CreatorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        127 => listener.enter_created_name(&CreatedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        128 => listener.enter_inner_creator(&InnerCreatorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        129 => listener.enter_array_creator_rest(&ArrayCreatorRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        130 => listener.enter_class_creator_rest(&ClassCreatorRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        131 => listener.enter_explicit_generic_invocation(&ExplicitGenericInvocationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        132 => listener.enter_type_arguments_or_diamond(&TypeArgumentsOrDiamondContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        133 => listener.enter_non_wildcard_type_arguments_or_diamond(&NonWildcardTypeArgumentsOrDiamondContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        134 => listener.enter_non_wildcard_type_arguments(&NonWildcardTypeArgumentsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        135 => listener.enter_type_list(&TypeListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        136 => listener.enter_type_type(&TypeTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        137 => listener.enter_primitive_type(&PrimitiveTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        138 => listener.enter_type_arguments(&TypeArgumentsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        139 => listener.enter_super_suffix(&SuperSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        140 => listener.enter_explicit_generic_invocation_suffix(&ExplicitGenericInvocationSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        141 => listener.enter_arguments(&ArgumentsContext::__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_modular_compulation_unit(&ModularCompulationUnitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_package_declaration(&PackageDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_import_declaration(&ImportDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_type_declaration(&TypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_modifier(&ModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_class_or_interface_modifier(&ClassOrInterfaceModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_variable_modifier(&VariableModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_class_declaration(&ClassDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_type_parameters(&TypeParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_type_parameter(&TypeParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_type_bound(&TypeBoundContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_enum_declaration(&EnumDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_enum_constants(&EnumConstantsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_enum_constant(&EnumConstantContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_enum_body_declarations(&EnumBodyDeclarationsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_interface_declaration(&InterfaceDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_class_body(&ClassBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_interface_body(&InterfaceBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_class_body_declaration(&ClassBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_member_declaration(&MemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_method_declaration(&MethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_method_body(&MethodBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_type_type_or_void(&TypeTypeOrVoidContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_generic_method_declaration(&GenericMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_generic_constructor_declaration(&GenericConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_constructor_declaration(&ConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_compact_constructor_declaration(&CompactConstructorDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_field_declaration(&FieldDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_interface_body_declaration(&InterfaceBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_interface_member_declaration(&InterfaceMemberDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_const_declaration(&ConstDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_constant_declarator(&ConstantDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_interface_method_declaration(&InterfaceMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_interface_method_modifier(&InterfaceMethodModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_generic_interface_method_declaration(&GenericInterfaceMethodDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_interface_common_body_declaration(&InterfaceCommonBodyDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_variable_declarators(&VariableDeclaratorsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_variable_declarator(&VariableDeclaratorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_variable_declarator_id(&VariableDeclaratorIdContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_variable_initializer(&VariableInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_array_initializer(&ArrayInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_class_type(&ClassTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_package_name(&PackageNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_type_argument(&TypeArgumentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_qualified_name_list(&QualifiedNameListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_formal_parameters(&FormalParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_receiver_parameter(&ReceiverParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_formal_parameter_list(&FormalParameterListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_formal_parameter(&FormalParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_lambda_lvti_list(&LambdaLvtiListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_lambda_lvti_parameter(&LambdaLvtiParameterContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_qualified_name(&QualifiedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_literal(&LiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_integer_literal(&IntegerLiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_float_literal(&FloatLiteralContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_annotation(&AnnotationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_annotation_field_values(&AnnotationFieldValuesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_annotation_field_value(&AnnotationFieldValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_annotation_value(&AnnotationValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_element_value(&ElementValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_element_value_array_initializer(&ElementValueArrayInitializerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_annotation_type_declaration(&AnnotationTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_annotation_type_body(&AnnotationTypeBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_annotation_type_element_declaration(&AnnotationTypeElementDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_annotation_type_element_rest(&AnnotationTypeElementRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_annotation_method_or_constant_rest(&AnnotationMethodOrConstantRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    67 => listener.exit_annotation_method_rest(&AnnotationMethodRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    68 => listener.exit_annotation_constant_rest(&AnnotationConstantRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    69 => listener.exit_default_value(&DefaultValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    70 => listener.exit_module_declaration(&ModuleDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    71 => listener.exit_module_directive(&ModuleDirectiveContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    72 => listener.exit_requires_modifier(&RequiresModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    73 => listener.exit_record_declaration(&RecordDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    74 => listener.exit_record_header(&RecordHeaderContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    75 => listener.exit_record_component_list(&RecordComponentListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    76 => listener.exit_record_component(&RecordComponentContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    77 => listener.exit_record_body(&RecordBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    78 => listener.exit_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    79 => listener.exit_block_statement(&BlockStatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    80 => listener.exit_local_variable_declaration(&LocalVariableDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    81 => listener.exit_identifier(&IdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    82 => listener.exit_type_identifier(&TypeIdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    83 => listener.exit_local_type_declaration(&LocalTypeDeclarationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    84 => listener.exit_statement(&StatementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    85 => listener.exit_catch_clause(&CatchClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    86 => listener.exit_catch_type(&CatchTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    87 => listener.exit_finally_block(&FinallyBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    88 => listener.exit_resource_specification(&ResourceSpecificationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    89 => listener.exit_resources(&ResourcesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    90 => listener.exit_resource(&ResourceContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    91 => listener.exit_switch_block_statement_group(&SwitchBlockStatementGroupContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    92 => listener.exit_switch_label(&SwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    93 => listener.exit_for_control(&ForControlContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    94 => listener.exit_for_init(&ForInitContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    95 => listener.exit_enhanced_for_control(&EnhancedForControlContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    96 => listener.exit_expression_list(&ExpressionListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    97 => listener.exit_method_call(&MethodCallContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    98 => listener.exit_expression(&ExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    99 => listener.exit_primary_expression_label(&PrimaryExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    100 => listener.exit_square_bracket_expression_label(&SquareBracketExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    101 => listener.exit_member_reference_expression_label(&MemberReferenceExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    102 => listener.exit_method_call_expression_label(&MethodCallExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    103 => listener.exit_method_reference_expression_label(&MethodReferenceExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    104 => listener.exit_expression_switch_label(&ExpressionSwitchLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    105 => listener.exit_post_increment_decrement_operator_expression_label(&PostIncrementDecrementOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    106 => listener.exit_unary_operator_expression_label(&UnaryOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    107 => listener.exit_cast_expression_label(&CastExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    108 => listener.exit_object_creation_expression_label(&ObjectCreationExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    109 => listener.exit_binary_operator_expression_label(&BinaryOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    110 => listener.exit_instance_of_operator_expression_label(&InstanceOfOperatorExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    111 => listener.exit_ternary_expression_label(&TernaryExpressionLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    112 => listener.exit_expression_lambda_label(&ExpressionLambdaLabelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    113 => listener.exit_pattern(&PatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    114 => listener.exit_component_pattern_list(&ComponentPatternListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    115 => listener.exit_component_pattern(&ComponentPatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    116 => listener.exit_lambda_expression(&LambdaExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    117 => listener.exit_lambda_parameters(&LambdaParametersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    118 => listener.exit_lambda_body(&LambdaBodyContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    119 => listener.exit_primary(&PrimaryContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    120 => listener.exit_switch_expression(&SwitchExpressionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    121 => listener.exit_switch_labeled_rule(&SwitchLabeledRuleContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    122 => listener.exit_guard(&GuardContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    123 => listener.exit_case_pattern(&CasePatternContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    124 => listener.exit_switch_rule_outcome(&SwitchRuleOutcomeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    125 => listener.exit_class_or_interface_type(&ClassOrInterfaceTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    126 => listener.exit_creator(&CreatorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    127 => listener.exit_created_name(&CreatedNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    128 => listener.exit_inner_creator(&InnerCreatorContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    129 => listener.exit_array_creator_rest(&ArrayCreatorRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    130 => listener.exit_class_creator_rest(&ClassCreatorRestContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    131 => listener.exit_explicit_generic_invocation(&ExplicitGenericInvocationContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    132 => listener.exit_type_arguments_or_diamond(&TypeArgumentsOrDiamondContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    133 => listener.exit_non_wildcard_type_arguments_or_diamond(&NonWildcardTypeArgumentsOrDiamondContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    134 => listener.exit_non_wildcard_type_arguments(&NonWildcardTypeArgumentsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    135 => listener.exit_type_list(&TypeListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    136 => listener.exit_type_type(&TypeTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    137 => listener.exit_primitive_type(&PrimitiveTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    138 => listener.exit_type_arguments(&TypeArgumentsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    139 => listener.exit_super_suffix(&SuperSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    140 => listener.exit_explicit_generic_invocation_suffix(&ExplicitGenericInvocationSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    141 => listener.exit_arguments(&ArgumentsContext::__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 = JavaTreeWalker;

#[allow(dead_code, unused_variables)]
pub trait JavaValidatedListener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: ValidatedRuleNode<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        JavaValidatedTreeWalker::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_modular_compulation_unit(&mut self, _ctx: &ModularCompulationUnitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_modular_compulation_unit(&mut self, _ctx: &ModularCompulationUnitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_package_declaration(&mut self, _ctx: &PackageDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_package_declaration(&mut self, _ctx: &PackageDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_import_declaration(&mut self, _ctx: &ImportDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_import_declaration(&mut self, _ctx: &ImportDeclarationContext<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_modifier(&mut self, _ctx: &ModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_modifier(&mut self, _ctx: &ModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_or_interface_modifier(&mut self, _ctx: &ClassOrInterfaceModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_or_interface_modifier(&mut self, _ctx: &ClassOrInterfaceModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_modifier(&mut self, _ctx: &VariableModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_modifier(&mut self, _ctx: &VariableModifierContext<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_type_parameters(&mut self, _ctx: &TypeParametersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_parameters(&mut self, _ctx: &TypeParametersContext<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_bound(&mut self, _ctx: &TypeBoundContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_bound(&mut self, _ctx: &TypeBoundContext<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_enum_constants(&mut self, _ctx: &EnumConstantsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enum_constants(&mut self, _ctx: &EnumConstantsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_enum_constant(&mut self, _ctx: &EnumConstantContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enum_constant(&mut self, _ctx: &EnumConstantContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_enum_body_declarations(&mut self, _ctx: &EnumBodyDeclarationsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enum_body_declarations(&mut self, _ctx: &EnumBodyDeclarationsContext<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_class_body(&mut self, _ctx: &ClassBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_body(&mut self, _ctx: &ClassBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_body(&mut self, _ctx: &InterfaceBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_body(&mut self, _ctx: &InterfaceBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_body_declaration(&mut self, _ctx: &ClassBodyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_body_declaration(&mut self, _ctx: &ClassBodyDeclarationContext<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_method_declaration(&mut self, _ctx: &MethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_declaration(&mut self, _ctx: &MethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_method_body(&mut self, _ctx: &MethodBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_body(&mut self, _ctx: &MethodBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_type_or_void(&mut self, _ctx: &TypeTypeOrVoidContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_type_or_void(&mut self, _ctx: &TypeTypeOrVoidContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_generic_method_declaration(&mut self, _ctx: &GenericMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_generic_method_declaration(&mut self, _ctx: &GenericMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_generic_constructor_declaration(&mut self, _ctx: &GenericConstructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_generic_constructor_declaration(&mut self, _ctx: &GenericConstructorDeclarationContext<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_compact_constructor_declaration(&mut self, _ctx: &CompactConstructorDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_compact_constructor_declaration(&mut self, _ctx: &CompactConstructorDeclarationContext<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_interface_body_declaration(&mut self, _ctx: &InterfaceBodyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_body_declaration(&mut self, _ctx: &InterfaceBodyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_member_declaration(&mut self, _ctx: &InterfaceMemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_member_declaration(&mut self, _ctx: &InterfaceMemberDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_const_declaration(&mut self, _ctx: &ConstDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_const_declaration(&mut self, _ctx: &ConstDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_constant_declarator(&mut self, _ctx: &ConstantDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_constant_declarator(&mut self, _ctx: &ConstantDeclaratorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_method_declaration(&mut self, _ctx: &InterfaceMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_method_declaration(&mut self, _ctx: &InterfaceMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_method_modifier(&mut self, _ctx: &InterfaceMethodModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_method_modifier(&mut self, _ctx: &InterfaceMethodModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_generic_interface_method_declaration(&mut self, _ctx: &GenericInterfaceMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_generic_interface_method_declaration(&mut self, _ctx: &GenericInterfaceMethodDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_interface_common_body_declaration(&mut self, _ctx: &InterfaceCommonBodyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_interface_common_body_declaration(&mut self, _ctx: &InterfaceCommonBodyDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_declarators(&mut self, _ctx: &VariableDeclaratorsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarators(&mut self, _ctx: &VariableDeclaratorsContext<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_variable_declarator_id(&mut self, _ctx: &VariableDeclaratorIdContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_declarator_id(&mut self, _ctx: &VariableDeclaratorIdContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_variable_initializer(&mut self, _ctx: &VariableInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_variable_initializer(&mut self, _ctx: &VariableInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_array_initializer(&mut self, _ctx: &ArrayInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_array_initializer(&mut self, _ctx: &ArrayInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_type(&mut self, _ctx: &ClassTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_type(&mut self, _ctx: &ClassTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_package_name(&mut self, _ctx: &PackageNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_package_name(&mut self, _ctx: &PackageNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_argument(&mut self, _ctx: &TypeArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_argument(&mut self, _ctx: &TypeArgumentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_qualified_name_list(&mut self, _ctx: &QualifiedNameListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_qualified_name_list(&mut self, _ctx: &QualifiedNameListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameters(&mut self, _ctx: &FormalParametersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameters(&mut self, _ctx: &FormalParametersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_receiver_parameter(&mut self, _ctx: &ReceiverParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_receiver_parameter(&mut self, _ctx: &ReceiverParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameter_list(&mut self, _ctx: &FormalParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameter_list(&mut self, _ctx: &FormalParameterListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_formal_parameter(&mut self, _ctx: &FormalParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_formal_parameter(&mut self, _ctx: &FormalParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lambda_lvti_list(&mut self, _ctx: &LambdaLvtiListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lambda_lvti_list(&mut self, _ctx: &LambdaLvtiListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lambda_lvti_parameter(&mut self, _ctx: &LambdaLvtiParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lambda_lvti_parameter(&mut self, _ctx: &LambdaLvtiParameterContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_qualified_name(&mut self, _ctx: &QualifiedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_qualified_name(&mut self, _ctx: &QualifiedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_literal(&mut self, _ctx: &LiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_literal(&mut self, _ctx: &LiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_integer_literal(&mut self, _ctx: &IntegerLiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_integer_literal(&mut self, _ctx: &IntegerLiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_float_literal(&mut self, _ctx: &FloatLiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_float_literal(&mut self, _ctx: &FloatLiteralContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation(&mut self, _ctx: &AnnotationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation(&mut self, _ctx: &AnnotationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_field_values(&mut self, _ctx: &AnnotationFieldValuesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_field_values(&mut self, _ctx: &AnnotationFieldValuesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_field_value(&mut self, _ctx: &AnnotationFieldValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_field_value(&mut self, _ctx: &AnnotationFieldValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_value(&mut self, _ctx: &AnnotationValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_value(&mut self, _ctx: &AnnotationValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element_value(&mut self, _ctx: &ElementValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element_value(&mut self, _ctx: &ElementValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element_value_array_initializer(&mut self, _ctx: &ElementValueArrayInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element_value_array_initializer(&mut self, _ctx: &ElementValueArrayInitializerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_declaration(&mut self, _ctx: &AnnotationTypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_declaration(&mut self, _ctx: &AnnotationTypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_body(&mut self, _ctx: &AnnotationTypeBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_body(&mut self, _ctx: &AnnotationTypeBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_element_declaration(&mut self, _ctx: &AnnotationTypeElementDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_element_declaration(&mut self, _ctx: &AnnotationTypeElementDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_type_element_rest(&mut self, _ctx: &AnnotationTypeElementRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_type_element_rest(&mut self, _ctx: &AnnotationTypeElementRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_method_or_constant_rest(&mut self, _ctx: &AnnotationMethodOrConstantRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_method_or_constant_rest(&mut self, _ctx: &AnnotationMethodOrConstantRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_method_rest(&mut self, _ctx: &AnnotationMethodRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_method_rest(&mut self, _ctx: &AnnotationMethodRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_annotation_constant_rest(&mut self, _ctx: &AnnotationConstantRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_annotation_constant_rest(&mut self, _ctx: &AnnotationConstantRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_default_value(&mut self, _ctx: &DefaultValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_default_value(&mut self, _ctx: &DefaultValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_module_declaration(&mut self, _ctx: &ModuleDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_module_declaration(&mut self, _ctx: &ModuleDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_module_directive(&mut self, _ctx: &ModuleDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_module_directive(&mut self, _ctx: &ModuleDirectiveContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_requires_modifier(&mut self, _ctx: &RequiresModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_requires_modifier(&mut self, _ctx: &RequiresModifierContext<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_record_header(&mut self, _ctx: &RecordHeaderContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_header(&mut self, _ctx: &RecordHeaderContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_record_component_list(&mut self, _ctx: &RecordComponentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_component_list(&mut self, _ctx: &RecordComponentListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_record_component(&mut self, _ctx: &RecordComponentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_component(&mut self, _ctx: &RecordComponentContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_record_body(&mut self, _ctx: &RecordBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_record_body(&mut self, _ctx: &RecordBodyContext<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_block_statement(&mut self, _ctx: &BlockStatementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_block_statement(&mut self, _ctx: &BlockStatementContext<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_identifier(&mut self, _ctx: &IdentifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_identifier(&mut self, _ctx: &IdentifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_identifier(&mut self, _ctx: &TypeIdentifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_identifier(&mut self, _ctx: &TypeIdentifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_local_type_declaration(&mut self, _ctx: &LocalTypeDeclarationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_local_type_declaration(&mut self, _ctx: &LocalTypeDeclarationContext<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_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_type(&mut self, _ctx: &CatchTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_catch_type(&mut self, _ctx: &CatchTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_finally_block(&mut self, _ctx: &FinallyBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_finally_block(&mut self, _ctx: &FinallyBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_resource_specification(&mut self, _ctx: &ResourceSpecificationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_resource_specification(&mut self, _ctx: &ResourceSpecificationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_resources(&mut self, _ctx: &ResourcesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_resources(&mut self, _ctx: &ResourcesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_resource(&mut self, _ctx: &ResourceContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_resource(&mut self, _ctx: &ResourceContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_block_statement_group(&mut self, _ctx: &SwitchBlockStatementGroupContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_block_statement_group(&mut self, _ctx: &SwitchBlockStatementGroupContext<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_for_control(&mut self, _ctx: &ForControlContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_for_control(&mut self, _ctx: &ForControlContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_for_init(&mut self, _ctx: &ForInitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_for_init(&mut self, _ctx: &ForInitContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_enhanced_for_control(&mut self, _ctx: &EnhancedForControlContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_enhanced_for_control(&mut self, _ctx: &EnhancedForControlContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_list(&mut self, _ctx: &ExpressionListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_list(&mut self, _ctx: &ExpressionListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_method_call(&mut self, _ctx: &MethodCallContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_call(&mut self, _ctx: &MethodCallContext<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_primary_expression_label(&mut self, _ctx: &PrimaryExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_primary_expression_label(&mut self, _ctx: &PrimaryExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_square_bracket_expression_label(&mut self, _ctx: &SquareBracketExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_square_bracket_expression_label(&mut self, _ctx: &SquareBracketExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_member_reference_expression_label(&mut self, _ctx: &MemberReferenceExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_member_reference_expression_label(&mut self, _ctx: &MemberReferenceExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_method_call_expression_label(&mut self, _ctx: &MethodCallExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_call_expression_label(&mut self, _ctx: &MethodCallExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_method_reference_expression_label(&mut self, _ctx: &MethodReferenceExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_method_reference_expression_label(&mut self, _ctx: &MethodReferenceExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_switch_label(&mut self, _ctx: &ExpressionSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_switch_label(&mut self, _ctx: &ExpressionSwitchLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_post_increment_decrement_operator_expression_label(&mut self, _ctx: &PostIncrementDecrementOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_post_increment_decrement_operator_expression_label(&mut self, _ctx: &PostIncrementDecrementOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_unary_operator_expression_label(&mut self, _ctx: &UnaryOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_unary_operator_expression_label(&mut self, _ctx: &UnaryOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_cast_expression_label(&mut self, _ctx: &CastExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_cast_expression_label(&mut self, _ctx: &CastExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_object_creation_expression_label(&mut self, _ctx: &ObjectCreationExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_object_creation_expression_label(&mut self, _ctx: &ObjectCreationExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_binary_operator_expression_label(&mut self, _ctx: &BinaryOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_binary_operator_expression_label(&mut self, _ctx: &BinaryOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_instance_of_operator_expression_label(&mut self, _ctx: &InstanceOfOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_instance_of_operator_expression_label(&mut self, _ctx: &InstanceOfOperatorExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ternary_expression_label(&mut self, _ctx: &TernaryExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ternary_expression_label(&mut self, _ctx: &TernaryExpressionLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_expression_lambda_label(&mut self, _ctx: &ExpressionLambdaLabelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_expression_lambda_label(&mut self, _ctx: &ExpressionLambdaLabelContext<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_component_pattern_list(&mut self, _ctx: &ComponentPatternListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_component_pattern_list(&mut self, _ctx: &ComponentPatternListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_component_pattern(&mut self, _ctx: &ComponentPatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_component_pattern(&mut self, _ctx: &ComponentPatternContext<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_lambda_parameters(&mut self, _ctx: &LambdaParametersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lambda_parameters(&mut self, _ctx: &LambdaParametersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lambda_body(&mut self, _ctx: &LambdaBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lambda_body(&mut self, _ctx: &LambdaBodyContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_primary(&mut self, _ctx: &PrimaryContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_primary(&mut self, _ctx: &PrimaryContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_expression(&mut self, _ctx: &SwitchExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_expression(&mut self, _ctx: &SwitchExpressionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_labeled_rule(&mut self, _ctx: &SwitchLabeledRuleContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_labeled_rule(&mut self, _ctx: &SwitchLabeledRuleContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_guard(&mut self, _ctx: &GuardContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_guard(&mut self, _ctx: &GuardContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_case_pattern(&mut self, _ctx: &CasePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_case_pattern(&mut self, _ctx: &CasePatternContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_switch_rule_outcome(&mut self, _ctx: &SwitchRuleOutcomeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_switch_rule_outcome(&mut self, _ctx: &SwitchRuleOutcomeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_or_interface_type(&mut self, _ctx: &ClassOrInterfaceTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_or_interface_type(&mut self, _ctx: &ClassOrInterfaceTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_creator(&mut self, _ctx: &CreatorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_creator(&mut self, _ctx: &CreatorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_created_name(&mut self, _ctx: &CreatedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_created_name(&mut self, _ctx: &CreatedNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_inner_creator(&mut self, _ctx: &InnerCreatorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_inner_creator(&mut self, _ctx: &InnerCreatorContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_array_creator_rest(&mut self, _ctx: &ArrayCreatorRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_array_creator_rest(&mut self, _ctx: &ArrayCreatorRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_class_creator_rest(&mut self, _ctx: &ClassCreatorRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_class_creator_rest(&mut self, _ctx: &ClassCreatorRestContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_explicit_generic_invocation(&mut self, _ctx: &ExplicitGenericInvocationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_explicit_generic_invocation(&mut self, _ctx: &ExplicitGenericInvocationContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_arguments_or_diamond(&mut self, _ctx: &TypeArgumentsOrDiamondContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_arguments_or_diamond(&mut self, _ctx: &TypeArgumentsOrDiamondContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_non_wildcard_type_arguments_or_diamond(&mut self, _ctx: &NonWildcardTypeArgumentsOrDiamondContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_non_wildcard_type_arguments_or_diamond(&mut self, _ctx: &NonWildcardTypeArgumentsOrDiamondContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_non_wildcard_type_arguments(&mut self, _ctx: &NonWildcardTypeArgumentsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_non_wildcard_type_arguments(&mut self, _ctx: &NonWildcardTypeArgumentsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_list(&mut self, _ctx: &TypeListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_list(&mut self, _ctx: &TypeListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_type(&mut self, _ctx: &TypeTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_type(&mut self, _ctx: &TypeTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_primitive_type(&mut self, _ctx: &PrimitiveTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_primitive_type(&mut self, _ctx: &PrimitiveTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_type_arguments(&mut self, _ctx: &TypeArgumentsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_type_arguments(&mut self, _ctx: &TypeArgumentsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_super_suffix(&mut self, _ctx: &SuperSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_super_suffix(&mut self, _ctx: &SuperSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_explicit_generic_invocation_suffix(&mut self, _ctx: &ExplicitGenericInvocationSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_explicit_generic_invocation_suffix(&mut self, _ctx: &ExplicitGenericInvocationSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_arguments(&mut self, _ctx: &ArgumentsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_arguments(&mut self, _ctx: &ArgumentsContext<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 JavaValidatedTreeWalker;

#[allow(dead_code)]
impl JavaValidatedTreeWalker {
    pub fn walk<E, T: JavaValidatedListener<E>>(
        listener: &mut T,
        tree: ValidatedRuleNode<'_>,
    ) -> Result<(), E> {
        Self::__walk(listener, tree.node(), None)
    }

    pub fn walk_with_invocation_states<E, T: JavaValidatedListener<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: JavaValidatedListener<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_modular_compulation_unit(&ModularCompulationUnitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_package_declaration(&PackageDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_import_declaration(&ImportDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_type_declaration(&TypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_modifier(&ModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_class_or_interface_modifier(&ClassOrInterfaceModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_variable_modifier(&VariableModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_class_declaration(&ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_type_parameters(&TypeParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_type_parameter(&TypeParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_type_bound(&TypeBoundContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_enum_declaration(&EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_enum_constants(&EnumConstantsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_enum_constant(&EnumConstantContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_enum_body_declarations(&EnumBodyDeclarationsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_interface_declaration(&InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_class_body(&ClassBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_interface_body(&InterfaceBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_class_body_declaration(&ClassBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_member_declaration(&MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_method_declaration(&MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_method_body(&MethodBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_type_type_or_void(&TypeTypeOrVoidContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_generic_method_declaration(&GenericMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_generic_constructor_declaration(&GenericConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_constructor_declaration(&ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_compact_constructor_declaration(&CompactConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_field_declaration(&FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_interface_body_declaration(&InterfaceBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_interface_member_declaration(&InterfaceMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_const_declaration(&ConstDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_constant_declarator(&ConstantDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_interface_method_declaration(&InterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_interface_method_modifier(&InterfaceMethodModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_generic_interface_method_declaration(&GenericInterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_interface_common_body_declaration(&InterfaceCommonBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_variable_declarators(&VariableDeclaratorsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_variable_declarator(&VariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_variable_declarator_id(&VariableDeclaratorIdContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_variable_initializer(&VariableInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_array_initializer(&ArrayInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_class_type(&ClassTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_package_name(&PackageNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_type_argument(&TypeArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_qualified_name_list(&QualifiedNameListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_formal_parameters(&FormalParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_receiver_parameter(&ReceiverParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_formal_parameter_list(&FormalParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_formal_parameter(&FormalParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_lambda_lvti_list(&LambdaLvtiListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_lambda_lvti_parameter(&LambdaLvtiParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_qualified_name(&QualifiedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_literal(&LiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_integer_literal(&IntegerLiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_float_literal(&FloatLiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_annotation(&AnnotationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_annotation_field_values(&AnnotationFieldValuesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_annotation_field_value(&AnnotationFieldValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_annotation_value(&AnnotationValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_element_value(&ElementValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_element_value_array_initializer(&ElementValueArrayInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_annotation_type_declaration(&AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_annotation_type_body(&AnnotationTypeBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_annotation_type_element_declaration(&AnnotationTypeElementDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_annotation_type_element_rest(&AnnotationTypeElementRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_annotation_method_or_constant_rest(&AnnotationMethodOrConstantRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        67 => listener.enter_annotation_method_rest(&AnnotationMethodRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        68 => listener.enter_annotation_constant_rest(&AnnotationConstantRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        69 => listener.enter_default_value(&DefaultValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        70 => listener.enter_module_declaration(&ModuleDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        71 => listener.enter_module_directive(&ModuleDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        72 => listener.enter_requires_modifier(&RequiresModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        73 => listener.enter_record_declaration(&RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        74 => listener.enter_record_header(&RecordHeaderContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        75 => listener.enter_record_component_list(&RecordComponentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        76 => listener.enter_record_component(&RecordComponentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        77 => listener.enter_record_body(&RecordBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        78 => listener.enter_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        79 => listener.enter_block_statement(&BlockStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        80 => listener.enter_local_variable_declaration(&LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        81 => listener.enter_identifier(&IdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        82 => listener.enter_type_identifier(&TypeIdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        83 => listener.enter_local_type_declaration(&LocalTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        84 => listener.enter_statement(&StatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        85 => listener.enter_catch_clause(&CatchClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        86 => listener.enter_catch_type(&CatchTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        87 => listener.enter_finally_block(&FinallyBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        88 => listener.enter_resource_specification(&ResourceSpecificationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        89 => listener.enter_resources(&ResourcesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        90 => listener.enter_resource(&ResourceContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        91 => listener.enter_switch_block_statement_group(&SwitchBlockStatementGroupContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        92 => listener.enter_switch_label(&SwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        93 => listener.enter_for_control(&ForControlContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        94 => listener.enter_for_init(&ForInitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        95 => listener.enter_enhanced_for_control(&EnhancedForControlContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        96 => listener.enter_expression_list(&ExpressionListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        97 => listener.enter_method_call(&MethodCallContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        98 => listener.enter_expression(&ExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        99 => listener.enter_primary_expression_label(&PrimaryExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        100 => listener.enter_square_bracket_expression_label(&SquareBracketExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        101 => listener.enter_member_reference_expression_label(&MemberReferenceExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        102 => listener.enter_method_call_expression_label(&MethodCallExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        103 => listener.enter_method_reference_expression_label(&MethodReferenceExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        104 => listener.enter_expression_switch_label(&ExpressionSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        105 => listener.enter_post_increment_decrement_operator_expression_label(&PostIncrementDecrementOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        106 => listener.enter_unary_operator_expression_label(&UnaryOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        107 => listener.enter_cast_expression_label(&CastExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        108 => listener.enter_object_creation_expression_label(&ObjectCreationExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        109 => listener.enter_binary_operator_expression_label(&BinaryOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        110 => listener.enter_instance_of_operator_expression_label(&InstanceOfOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        111 => listener.enter_ternary_expression_label(&TernaryExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        112 => listener.enter_expression_lambda_label(&ExpressionLambdaLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        113 => listener.enter_pattern(&PatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        114 => listener.enter_component_pattern_list(&ComponentPatternListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        115 => listener.enter_component_pattern(&ComponentPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        116 => listener.enter_lambda_expression(&LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        117 => listener.enter_lambda_parameters(&LambdaParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        118 => listener.enter_lambda_body(&LambdaBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        119 => listener.enter_primary(&PrimaryContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        120 => listener.enter_switch_expression(&SwitchExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        121 => listener.enter_switch_labeled_rule(&SwitchLabeledRuleContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        122 => listener.enter_guard(&GuardContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        123 => listener.enter_case_pattern(&CasePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        124 => listener.enter_switch_rule_outcome(&SwitchRuleOutcomeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        125 => listener.enter_class_or_interface_type(&ClassOrInterfaceTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        126 => listener.enter_creator(&CreatorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        127 => listener.enter_created_name(&CreatedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        128 => listener.enter_inner_creator(&InnerCreatorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        129 => listener.enter_array_creator_rest(&ArrayCreatorRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        130 => listener.enter_class_creator_rest(&ClassCreatorRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        131 => listener.enter_explicit_generic_invocation(&ExplicitGenericInvocationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        132 => listener.enter_type_arguments_or_diamond(&TypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        133 => listener.enter_non_wildcard_type_arguments_or_diamond(&NonWildcardTypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        134 => listener.enter_non_wildcard_type_arguments(&NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        135 => listener.enter_type_list(&TypeListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        136 => listener.enter_type_type(&TypeTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        137 => listener.enter_primitive_type(&PrimitiveTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        138 => listener.enter_type_arguments(&TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        139 => listener.enter_super_suffix(&SuperSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        140 => listener.enter_explicit_generic_invocation_suffix(&ExplicitGenericInvocationSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        141 => listener.enter_arguments(&ArgumentsContext::<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_modular_compulation_unit(&ModularCompulationUnitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_package_declaration(&PackageDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_import_declaration(&ImportDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_type_declaration(&TypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_modifier(&ModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_class_or_interface_modifier(&ClassOrInterfaceModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_variable_modifier(&VariableModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_class_declaration(&ClassDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_type_parameters(&TypeParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_type_parameter(&TypeParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_type_bound(&TypeBoundContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_enum_declaration(&EnumDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_enum_constants(&EnumConstantsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_enum_constant(&EnumConstantContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_enum_body_declarations(&EnumBodyDeclarationsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_interface_declaration(&InterfaceDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_class_body(&ClassBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_interface_body(&InterfaceBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_class_body_declaration(&ClassBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_member_declaration(&MemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_method_declaration(&MethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_method_body(&MethodBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_type_type_or_void(&TypeTypeOrVoidContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_generic_method_declaration(&GenericMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_generic_constructor_declaration(&GenericConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_constructor_declaration(&ConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_compact_constructor_declaration(&CompactConstructorDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_field_declaration(&FieldDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_interface_body_declaration(&InterfaceBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_interface_member_declaration(&InterfaceMemberDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_const_declaration(&ConstDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_constant_declarator(&ConstantDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_interface_method_declaration(&InterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_interface_method_modifier(&InterfaceMethodModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_generic_interface_method_declaration(&GenericInterfaceMethodDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_interface_common_body_declaration(&InterfaceCommonBodyDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_variable_declarators(&VariableDeclaratorsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_variable_declarator(&VariableDeclaratorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_variable_declarator_id(&VariableDeclaratorIdContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_variable_initializer(&VariableInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_array_initializer(&ArrayInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_class_type(&ClassTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_package_name(&PackageNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_type_argument(&TypeArgumentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_qualified_name_list(&QualifiedNameListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_formal_parameters(&FormalParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_receiver_parameter(&ReceiverParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_formal_parameter_list(&FormalParameterListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_formal_parameter(&FormalParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_lambda_lvti_list(&LambdaLvtiListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_lambda_lvti_parameter(&LambdaLvtiParameterContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_qualified_name(&QualifiedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_literal(&LiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_integer_literal(&IntegerLiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_float_literal(&FloatLiteralContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_annotation(&AnnotationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_annotation_field_values(&AnnotationFieldValuesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_annotation_field_value(&AnnotationFieldValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_annotation_value(&AnnotationValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_element_value(&ElementValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_element_value_array_initializer(&ElementValueArrayInitializerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_annotation_type_declaration(&AnnotationTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_annotation_type_body(&AnnotationTypeBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_annotation_type_element_declaration(&AnnotationTypeElementDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_annotation_type_element_rest(&AnnotationTypeElementRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_annotation_method_or_constant_rest(&AnnotationMethodOrConstantRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    67 => listener.exit_annotation_method_rest(&AnnotationMethodRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    68 => listener.exit_annotation_constant_rest(&AnnotationConstantRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    69 => listener.exit_default_value(&DefaultValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    70 => listener.exit_module_declaration(&ModuleDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    71 => listener.exit_module_directive(&ModuleDirectiveContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    72 => listener.exit_requires_modifier(&RequiresModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    73 => listener.exit_record_declaration(&RecordDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    74 => listener.exit_record_header(&RecordHeaderContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    75 => listener.exit_record_component_list(&RecordComponentListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    76 => listener.exit_record_component(&RecordComponentContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    77 => listener.exit_record_body(&RecordBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    78 => listener.exit_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    79 => listener.exit_block_statement(&BlockStatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    80 => listener.exit_local_variable_declaration(&LocalVariableDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    81 => listener.exit_identifier(&IdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    82 => listener.exit_type_identifier(&TypeIdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    83 => listener.exit_local_type_declaration(&LocalTypeDeclarationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    84 => listener.exit_statement(&StatementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    85 => listener.exit_catch_clause(&CatchClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    86 => listener.exit_catch_type(&CatchTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    87 => listener.exit_finally_block(&FinallyBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    88 => listener.exit_resource_specification(&ResourceSpecificationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    89 => listener.exit_resources(&ResourcesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    90 => listener.exit_resource(&ResourceContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    91 => listener.exit_switch_block_statement_group(&SwitchBlockStatementGroupContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    92 => listener.exit_switch_label(&SwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    93 => listener.exit_for_control(&ForControlContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    94 => listener.exit_for_init(&ForInitContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    95 => listener.exit_enhanced_for_control(&EnhancedForControlContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    96 => listener.exit_expression_list(&ExpressionListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    97 => listener.exit_method_call(&MethodCallContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    98 => listener.exit_expression(&ExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    99 => listener.exit_primary_expression_label(&PrimaryExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    100 => listener.exit_square_bracket_expression_label(&SquareBracketExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    101 => listener.exit_member_reference_expression_label(&MemberReferenceExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    102 => listener.exit_method_call_expression_label(&MethodCallExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    103 => listener.exit_method_reference_expression_label(&MethodReferenceExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    104 => listener.exit_expression_switch_label(&ExpressionSwitchLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    105 => listener.exit_post_increment_decrement_operator_expression_label(&PostIncrementDecrementOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    106 => listener.exit_unary_operator_expression_label(&UnaryOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    107 => listener.exit_cast_expression_label(&CastExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    108 => listener.exit_object_creation_expression_label(&ObjectCreationExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    109 => listener.exit_binary_operator_expression_label(&BinaryOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    110 => listener.exit_instance_of_operator_expression_label(&InstanceOfOperatorExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    111 => listener.exit_ternary_expression_label(&TernaryExpressionLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    112 => listener.exit_expression_lambda_label(&ExpressionLambdaLabelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    113 => listener.exit_pattern(&PatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    114 => listener.exit_component_pattern_list(&ComponentPatternListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    115 => listener.exit_component_pattern(&ComponentPatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    116 => listener.exit_lambda_expression(&LambdaExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    117 => listener.exit_lambda_parameters(&LambdaParametersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    118 => listener.exit_lambda_body(&LambdaBodyContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    119 => listener.exit_primary(&PrimaryContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    120 => listener.exit_switch_expression(&SwitchExpressionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    121 => listener.exit_switch_labeled_rule(&SwitchLabeledRuleContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    122 => listener.exit_guard(&GuardContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    123 => listener.exit_case_pattern(&CasePatternContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    124 => listener.exit_switch_rule_outcome(&SwitchRuleOutcomeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    125 => listener.exit_class_or_interface_type(&ClassOrInterfaceTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    126 => listener.exit_creator(&CreatorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    127 => listener.exit_created_name(&CreatedNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    128 => listener.exit_inner_creator(&InnerCreatorContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    129 => listener.exit_array_creator_rest(&ArrayCreatorRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    130 => listener.exit_class_creator_rest(&ClassCreatorRestContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    131 => listener.exit_explicit_generic_invocation(&ExplicitGenericInvocationContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    132 => listener.exit_type_arguments_or_diamond(&TypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    133 => listener.exit_non_wildcard_type_arguments_or_diamond(&NonWildcardTypeArgumentsOrDiamondContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    134 => listener.exit_non_wildcard_type_arguments(&NonWildcardTypeArgumentsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    135 => listener.exit_type_list(&TypeListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    136 => listener.exit_type_type(&TypeTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    137 => listener.exit_primitive_type(&PrimitiveTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    138 => listener.exit_type_arguments(&TypeArgumentsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    139 => listener.exit_super_suffix(&SuperSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    140 => listener.exit_explicit_generic_invocation_suffix(&ExplicitGenericInvocationSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    141 => listener.exit_arguments(&ArgumentsContext::<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 = JavaValidatedTreeWalker;



static PARSER_ATN_DATA: &[u32] = &[1346458702, 2, 16909060, 29, 129, 1831, 2438, 15, 52, 230, 128, 29, 12817, 12846, 12190, 25036, 75, 25111, 104, 25279, 230, 25509, 128, 25637, 128, 25765, 32, 25215, 64, 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, 1, 4294967295, 4294967295, 2, 2, 8, 3, 1, 4294967295, 4294967295, 7, 2, 24, 4, 1, 4294967295, 4294967295, 2, 3, 8, 5, 1, 4294967295, 4294967295, 7, 3, 24, 6, 2, 4294967295, 4294967295, 2, 4, 8, 8, 1, 4294967295, 4294967295, 7, 4, 24, 9, 1, 4294967295, 4294967295, 2, 5, 8, 10, 1, 4294967295, 4294967295, 7, 5, 24, 11, 4, 4294967295, 4294967295, 2, 6, 8, 15, 1, 4294967295, 4294967295, 7, 6, 24, 16, 3, 4294967295, 4294967295, 2, 7, 8, 19, 1, 4294967295, 4294967295, 7, 7, 24, 20, 7, 4294967295, 4294967295, 2, 8, 8, 27, 1, 4294967295, 4294967295, 7, 8, 24, 28, 5, 4294967295, 4294967295, 2, 9, 8, 33, 1, 4294967295, 4294967295, 7, 9, 24, 34, 6, 4294967295, 4294967295, 2, 10, 8, 40, 1, 4294967295, 4294967295, 7, 10, 24, 41, 2, 4294967295, 4294967295, 2, 11, 8, 43, 1, 4294967295, 4294967295, 7, 11, 24, 44, 1, 4294967295, 4294967295, 2, 12, 8, 45, 1, 4294967295, 4294967295, 7, 12, 24, 46, 5, 4294967295, 4294967295, 2, 13, 8, 51, 1, 4294967295, 4294967295, 7, 13, 24, 52, 1, 4294967295, 4294967295, 2, 14, 8, 53, 1, 4294967295, 4294967295, 7, 14, 24, 54, 2, 4294967295, 4294967295, 2, 15, 8, 56, 1, 4294967295, 4294967295, 7, 15, 24, 57, 1, 4294967295, 4294967295, 2, 16, 8, 58, 1, 4294967295, 4294967295, 7, 16, 24, 59, 5, 4294967295, 4294967295, 2, 17, 8, 64, 1, 4294967295, 4294967295, 7, 17, 24, 65, 3, 4294967295, 4294967295, 2, 18, 8, 68, 1, 4294967295, 4294967295, 7, 18, 24, 69, 1, 4294967295, 4294967295, 2, 19, 8, 70, 1, 4294967295, 4294967295, 7, 19, 24, 71, 3, 4294967295, 4294967295, 2, 20, 8, 74, 1, 4294967295, 4294967295, 7, 20, 24, 75, 1, 4294967295, 4294967295, 2, 21, 8, 76, 1, 4294967295, 4294967295, 7, 21, 24, 77, 2, 4294967295, 4294967295, 2, 22, 8, 79, 1, 4294967295, 4294967295, 7, 22, 24, 80, 2, 4294967295, 4294967295, 2, 23, 8, 82, 1, 4294967295, 4294967295, 7, 23, 24, 83, 3, 4294967295, 4294967295, 2, 24, 8, 86, 1, 4294967295, 4294967295, 7, 24, 24, 87, 1, 4294967295, 4294967295, 2, 25, 8, 88, 1, 4294967295, 4294967295, 7, 25, 24, 89, 1, 4294967295, 4294967295, 2, 26, 8, 90, 1, 4294967295, 4294967295, 7, 26, 24, 91, 2, 4294967295, 4294967295, 2, 27, 8, 93, 1, 4294967295, 4294967295, 7, 27, 24, 94, 1, 4294967295, 4294967295, 2, 28, 8, 95, 1, 4294967295, 4294967295, 7, 28, 24, 96, 1, 4294967295, 4294967295, 2, 29, 8, 97, 1, 4294967295, 4294967295, 7, 29, 24, 98, 1, 4294967295, 4294967295, 2, 30, 8, 99, 1, 4294967295, 4294967295, 7, 30, 24, 100, 1, 4294967295, 4294967295, 2, 31, 8, 101, 1, 4294967295, 4294967295, 7, 31, 24, 102, 1, 4294967295, 4294967295, 2, 32, 8, 103, 1, 4294967295, 4294967295, 7, 32, 24, 104, 2, 4294967295, 4294967295, 2, 33, 8, 106, 1, 4294967295, 4294967295, 7, 33, 24, 107, 1, 4294967295, 4294967295, 2, 34, 8, 108, 1, 4294967295, 4294967295, 7, 34, 24, 109, 2, 4294967295, 4294967295, 2, 35, 8, 111, 1, 4294967295, 4294967295, 7, 35, 24, 112, 1, 4294967295, 4294967295, 2, 36, 8, 113, 1, 4294967295, 4294967295, 7, 36, 24, 114, 2, 4294967295, 4294967295, 2, 37, 8, 116, 1, 4294967295, 4294967295, 7, 37, 24, 117, 4, 4294967295, 4294967295, 2, 38, 8, 121, 1, 4294967295, 4294967295, 7, 38, 24, 122, 2, 4294967295, 4294967295, 2, 39, 8, 124, 1, 4294967295, 4294967295, 7, 39, 24, 125, 4, 4294967295, 4294967295, 2, 40, 8, 129, 1, 4294967295, 4294967295, 7, 40, 24, 130, 4, 4294967295, 4294967295, 2, 41, 8, 134, 1, 4294967295, 4294967295, 7, 41, 24, 135, 2, 4294967295, 4294967295, 2, 42, 8, 137, 1, 4294967295, 4294967295, 7, 42, 24, 138, 2, 4294967295, 4294967295, 2, 43, 8, 140, 1, 4294967295, 4294967295, 7, 43, 24, 141, 1, 4294967295, 4294967295, 2, 44, 8, 142, 1, 4294967295, 4294967295, 7, 44, 24, 143, 2, 4294967295, 4294967295, 2, 45, 8, 145, 1, 4294967295, 4294967295, 7, 45, 24, 146, 3, 4294967295, 4294967295, 2, 46, 8, 149, 1, 4294967295, 4294967295, 7, 46, 24, 150, 3, 4294967295, 4294967295, 2, 47, 8, 153, 1, 4294967295, 4294967295, 7, 47, 24, 154, 1, 4294967295, 4294967295, 2, 48, 8, 155, 1, 4294967295, 4294967295, 7, 48, 24, 156, 2, 4294967295, 4294967295, 2, 49, 8, 158, 1, 4294967295, 4294967295, 7, 49, 24, 159, 3, 4294967295, 4294967295, 2, 50, 8, 162, 1, 4294967295, 4294967295, 7, 50, 24, 163, 1, 4294967295, 4294967295, 2, 51, 8, 164, 1, 4294967295, 4294967295, 7, 51, 24, 165, 2, 4294967295, 4294967295, 2, 52, 8, 167, 1, 4294967295, 4294967295, 7, 52, 24, 168, 20, 4294967295, 4294967295, 2, 53, 8, 188, 1, 4294967295, 4294967295, 7, 53, 24, 189, 1, 4294967295, 4294967295, 2, 54, 8, 190, 1, 4294967295, 4294967295, 7, 54, 24, 191, 1, 4294967295, 4294967295, 2, 55, 8, 192, 1, 4294967295, 4294967295, 7, 55, 24, 193, 1, 4294967295, 4294967295, 2, 56, 8, 194, 1, 4294967295, 4294967295, 7, 56, 24, 195, 21, 4294967295, 4294967295, 2, 57, 8, 216, 1, 4294967295, 4294967295, 7, 57, 24, 217, 1, 4294967295, 4294967295, 2, 58, 8, 218, 1, 4294967295, 4294967295, 7, 58, 24, 219, 2, 4294967295, 4294967295, 2, 59, 8, 221, 1, 4294967295, 4294967295, 7, 59, 24, 222, 4, 4294967295, 4294967295, 2, 60, 8, 226, 1, 4294967295, 4294967295, 7, 60, 24, 227, 3, 4294967295, 4294967295, 2, 61, 8, 230, 1, 4294967295, 4294967295, 7, 61, 24, 231, 1, 4294967295, 4294967295, 2, 62, 8, 232, 1, 4294967295, 4294967295, 7, 62, 24, 233, 4, 4294967295, 4294967295, 2, 63, 8, 237, 1, 4294967295, 4294967295, 7, 63, 24, 238, 1, 4294967295, 4294967295, 2, 64, 8, 239, 1, 4294967295, 4294967295, 7, 64, 24, 240, 1, 4294967295, 4294967295, 2, 65, 8, 241, 1, 4294967295, 4294967295, 7, 65, 24, 242, 1, 4294967295, 4294967295, 2, 66, 8, 243, 1, 4294967295, 4294967295, 7, 66, 24, 244, 1, 4294967295, 4294967295, 2, 67, 8, 245, 1, 4294967295, 4294967295, 7, 67, 24, 246, 1, 4294967295, 4294967295, 2, 68, 8, 247, 1, 4294967295, 4294967295, 7, 68, 24, 248, 1, 4294967295, 4294967295, 2, 69, 8, 249, 1, 4294967295, 4294967295, 7, 69, 24, 250, 1, 4294967295, 4294967295, 2, 70, 8, 251, 1, 4294967295, 4294967295, 7, 70, 24, 252, 1, 4294967295, 4294967295, 2, 71, 8, 253, 1, 4294967295, 4294967295, 7, 71, 24, 254, 1, 4294967295, 4294967295, 2, 72, 8, 255, 1, 4294967295, 4294967295, 7, 72, 24, 256, 1, 4294967295, 4294967295, 2, 73, 8, 257, 1, 4294967295, 4294967295, 7, 73, 24, 258, 5, 4294967295, 4294967295, 2, 74, 8, 263, 1, 4294967295, 4294967295, 7, 74, 24, 264, 1, 4294967295, 4294967295, 2, 75, 8, 265, 1, 4294967295, 4294967295, 7, 75, 24, 266, 1, 4294967295, 4294967295, 2, 76, 8, 267, 1, 4294967295, 4294967295, 7, 76, 24, 268, 2, 4294967295, 4294967295, 2, 77, 8, 270, 1, 4294967295, 4294967295, 7, 77, 24, 271, 1, 4294967295, 4294967295, 2, 78, 8, 272, 1, 4294967295, 4294967295, 7, 78, 24, 273, 12, 4294967295, 4294967295, 2, 79, 8, 285, 1, 4294967295, 4294967295, 7, 79, 24, 286, 3, 4294967295, 4294967295, 2, 80, 8, 289, 1, 4294967295, 4294967295, 7, 80, 24, 290, 2, 4294967295, 4294967295, 2, 81, 8, 292, 1, 4294967295, 4294967295, 7, 81, 24, 293, 42, 4294967295, 4294967295, 2, 82, 8, 335, 1, 4294967295, 4294967295, 7, 82, 24, 336, 2, 4294967295, 4294967295, 2, 83, 8, 338, 1, 4294967295, 4294967295, 7, 83, 24, 339, 1, 4294967295, 4294967295, 2, 84, 8, 340, 1, 4294967295, 4294967295, 7, 84, 24, 341, 7, 4294967295, 4294967295, 2, 85, 8, 348, 1, 4294967295, 4294967295, 7, 85, 24, 349, 2, 4294967295, 4294967295, 2, 86, 8, 351, 1, 4294967295, 4294967295, 7, 86, 24, 352, 1, 4294967295, 4294967295, 2, 87, 8, 353, 1, 4294967295, 4294967295, 7, 87, 24, 354, 3, 4294967295, 4294967295, 2, 88, 8, 357, 1, 4294967295, 4294967295, 7, 88, 24, 358, 1, 4294967295, 4294967295, 2, 89, 8, 359, 1, 4294967295, 4294967295, 7, 89, 24, 360, 1, 4294967295, 4294967295, 2, 90, 8, 361, 1, 4294967295, 4294967295, 7, 90, 24, 362, 2, 4294967295, 4294967295, 2, 91, 8, 364, 1, 4294967295, 4294967295, 7, 91, 24, 365, 1, 4294967295, 4294967295, 2, 92, 8, 366, 1, 4294967295, 4294967295, 7, 92, 24, 367, 2, 4294967295, 4294967295, 2, 93, 8, 369, 1, 4294967295, 4294967295, 7, 93, 24, 370, 1, 4294967295, 4294967295, 2, 94, 8, 371, 1, 4294967295, 4294967295, 7, 94, 24, 372, 1, 4294967295, 4294967295, 2, 95, 8, 373, 1, 4294967295, 4294967295, 7, 95, 24, 374, 1, 4294967295, 4294967295, 2, 96, 8, 375, 1, 4294967295, 4294967295, 7, 96, 24, 376, 4, 4294967295, 4294967295, 2, 97, 8, 380, 1, 4294967295, 4294967295, 7, 97, 24, 381, 2, 4294967295, 4294967295, 2, 98, 12, 383, 1, 4294967295, 4294967295, 7, 98, 24, 384, 32, 4294967295, 4294967295, 2, 99, 8, 416, 1, 4294967295, 4294967295, 7, 99, 24, 417, 3, 4294967295, 4294967295, 2, 100, 8, 420, 1, 4294967295, 4294967295, 7, 100, 24, 421, 1, 4294967295, 4294967295, 2, 101, 8, 422, 1, 4294967295, 4294967295, 7, 101, 24, 423, 2, 4294967295, 4294967295, 2, 102, 8, 425, 1, 4294967295, 4294967295, 7, 102, 24, 426, 1, 4294967295, 4294967295, 2, 103, 8, 427, 1, 4294967295, 4294967295, 7, 103, 24, 428, 1, 4294967295, 4294967295, 2, 104, 8, 429, 1, 4294967295, 4294967295, 7, 104, 24, 430, 1, 4294967295, 4294967295, 2, 105, 8, 431, 1, 4294967295, 4294967295, 7, 105, 24, 432, 1, 4294967295, 4294967295, 2, 106, 8, 433, 1, 4294967295, 4294967295, 7, 106, 24, 434, 2, 4294967295, 4294967295, 2, 107, 8, 436, 1, 4294967295, 4294967295, 7, 107, 24, 437, 1, 4294967295, 4294967295, 2, 108, 8, 438, 1, 4294967295, 4294967295, 7, 108, 24, 439, 1, 4294967295, 4294967295, 2, 109, 8, 440, 1, 4294967295, 4294967295, 7, 109, 24, 441, 2, 4294967295, 4294967295, 2, 110, 8, 443, 1, 4294967295, 4294967295, 7, 110, 24, 444, 1, 4294967295, 4294967295, 2, 111, 8, 445, 1, 4294967295, 4294967295, 7, 111, 24, 446, 2, 4294967295, 4294967295, 2, 112, 8, 448, 1, 4294967295, 4294967295, 7, 112, 24, 449, 1, 4294967295, 4294967295, 2, 113, 8, 450, 1, 4294967295, 4294967295, 7, 113, 24, 451, 2, 4294967295, 4294967295, 2, 114, 8, 453, 1, 4294967295, 4294967295, 7, 114, 24, 454, 1, 4294967295, 4294967295, 2, 115, 8, 455, 1, 4294967295, 4294967295, 7, 115, 24, 456, 1, 4294967295, 4294967295, 2, 116, 8, 457, 1, 4294967295, 4294967295, 7, 116, 24, 458, 2, 4294967295, 4294967295, 2, 117, 8, 460, 1, 4294967295, 4294967295, 7, 117, 24, 461, 1, 4294967295, 4294967295, 2, 118, 8, 462, 1, 4294967295, 4294967295, 7, 118, 24, 463, 2, 4294967295, 4294967295, 2, 119, 8, 465, 1, 4294967295, 4294967295, 7, 119, 24, 466, 1, 4294967295, 4294967295, 2, 120, 8, 467, 1, 4294967295, 4294967295, 7, 120, 24, 468, 5, 4294967295, 4294967295, 2, 121, 8, 473, 1, 4294967295, 4294967295, 7, 121, 24, 474, 7, 4294967295, 4294967295, 2, 122, 8, 481, 1, 4294967295, 4294967295, 7, 122, 24, 482, 23, 4294967295, 4294967295, 2, 123, 8, 505, 1, 4294967295, 4294967295, 7, 123, 24, 506, 2, 4294967295, 4294967295, 2, 124, 8, 508, 1, 4294967295, 4294967295, 7, 124, 24, 509, 7, 4294967295, 4294967295, 2, 125, 8, 516, 1, 4294967295, 4294967295, 7, 125, 24, 517, 2, 4294967295, 4294967295, 2, 126, 8, 519, 1, 4294967295, 4294967295, 7, 126, 24, 520, 2, 4294967295, 4294967295, 2, 127, 8, 522, 1, 4294967295, 4294967295, 7, 127, 24, 523, 7, 4294967295, 4294967295, 1, 0, 8, 530, 1, 4294967295, 4294967295, 3, 0, 8, 531, 2, 258, 4294967295, 8, 0, 8, 533, 1, 4294967295, 4294967295, 1, 0, 8, 534, 1, 4294967295, 4294967295, 1, 0, 32, 535, 1, 4294967295, 4294967295, 5, 0, 8, 536, 2, 262, 4294967295, 8, 0, 8, 538, 1, 4294967295, 4294967295, 10, 0, 8, 539, 2, 4294967295, 4294967295, 12, 0, 8, 541, 1, 4294967295, 265, 9, 0, 8, 542, 1, 4294967295, 4294967295, 1, 0, 8, 543, 1, 4294967295, 4294967295, 1, 0, 32, 544, 1, 4294967295, 4294967295, 5, 0, 8, 545, 2, 269, 4294967295, 8, 0, 8, 547, 1, 4294967295, 4294967295, 10, 0, 8, 548, 2, 4294967295, 4294967295, 12, 0, 8, 550, 1, 4294967295, 272, 9, 0, 8, 551, 1, 4294967295, 4294967295, 1, 0, 32, 552, 1, 4294967295, 4294967295, 1, 0, 8, 553, 1, 4294967295, 4294967295, 1, 0, 32, 554, 1, 4294967295, 4294967295, 1, 0, 8, 555, 1, 4294967295, 4294967295, 3, 0, 8, 556, 2, 278, 4294967295, 8, 0, 8, 558, 1, 4294967295, 4294967295, 1, 1, 8, 559, 1, 4294967295, 4294967295, 5, 1, 8, 560, 1, 281, 4294967295, 8, 1, 8, 561, 1, 4294967295, 4294967295, 10, 1, 8, 562, 2, 4294967295, 4294967295, 12, 1, 8, 564, 1, 4294967295, 284, 9, 1, 8, 565, 1, 4294967295, 4294967295, 1, 1, 8, 566, 1, 4294967295, 4294967295, 1, 1, 8, 567, 1, 4294967295, 4294967295, 1, 2, 8, 568, 1, 4294967295, 4294967295, 5, 2, 8, 569, 1, 289, 4294967295, 8, 2, 8, 570, 1, 4294967295, 4294967295, 10, 2, 8, 571, 2, 4294967295, 4294967295, 12, 2, 8, 573, 1, 4294967295, 292, 9, 2, 8, 574, 1, 4294967295, 4294967295, 1, 2, 32, 575, 1, 4294967295, 4294967295, 1, 2, 8, 576, 1, 4294967295, 4294967295, 1, 2, 32, 577, 1, 4294967295, 4294967295, 1, 2, 8, 578, 1, 4294967295, 4294967295, 1, 3, 32, 579, 1, 4294967295, 4294967295, 1, 3, 32, 580, 1, 4294967295, 4294967295, 3, 3, 8, 581, 2, 300, 4294967295, 8, 3, 8, 583, 1, 4294967295, 4294967295, 1, 3, 8, 584, 1, 4294967295, 4294967295, 1, 3, 32, 585, 1, 4294967295, 4294967295, 1, 3, 32, 586, 1, 4294967295, 4294967295, 3, 3, 8, 587, 2, 305, 4294967295, 8, 3, 8, 589, 1, 4294967295, 4294967295, 1, 3, 32, 590, 1, 4294967295, 4294967295, 1, 3, 8, 591, 1, 4294967295, 4294967295, 1, 4, 8, 592, 1, 4294967295, 4294967295, 5, 4, 8, 593, 1, 310, 4294967295, 8, 4, 8, 594, 1, 4294967295, 4294967295, 10, 4, 8, 595, 2, 4294967295, 4294967295, 12, 4, 8, 597, 1, 4294967295, 313, 9, 4, 8, 598, 1, 4294967295, 4294967295, 1, 4, 8, 599, 1, 4294967295, 4294967295, 1, 4, 8, 600, 1, 4294967295, 4294967295, 1, 4, 8, 601, 1, 4294967295, 4294967295, 1, 4, 8, 602, 1, 4294967295, 4294967295, 1, 4, 8, 603, 1, 4294967295, 4294967295, 3, 4, 8, 604, 5, 320, 4294967295, 8, 4, 8, 609, 1, 4294967295, 4294967295, 1, 5, 8, 610, 1, 4294967295, 4294967295, 1, 5, 32, 611, 1, 4294967295, 4294967295, 1, 5, 32, 612, 1, 4294967295, 4294967295, 1, 5, 32, 613, 1, 4294967295, 4294967295, 1, 5, 32, 614, 1, 4294967295, 4294967295, 3, 5, 8, 615, 5, 327, 4294967295, 8, 5, 8, 620, 1, 4294967295, 4294967295, 1, 6, 8, 621, 1, 4294967295, 4294967295, 1, 6, 32, 622, 1, 4294967295, 4294967295, 1, 6, 32, 623, 1, 4294967295, 4294967295, 1, 6, 32, 624, 1, 4294967295, 4294967295, 1, 6, 32, 625, 1, 4294967295, 4294967295, 1, 6, 32, 626, 1, 4294967295, 4294967295, 1, 6, 32, 627, 1, 4294967295, 4294967295, 1, 6, 32, 628, 1, 4294967295, 4294967295, 1, 6, 32, 629, 1, 4294967295, 4294967295, 1, 6, 32, 630, 1, 4294967295, 4294967295, 3, 6, 8, 631, 10, 339, 4294967295, 8, 6, 8, 641, 1, 4294967295, 4294967295, 1, 7, 32, 642, 1, 4294967295, 4294967295, 1, 7, 8, 643, 1, 4294967295, 4294967295, 3, 7, 8, 644, 2, 343, 4294967295, 8, 7, 8, 646, 1, 4294967295, 4294967295, 1, 8, 32, 647, 1, 4294967295, 4294967295, 1, 8, 8, 648, 1, 4294967295, 4294967295, 1, 8, 8, 649, 1, 4294967295, 4294967295, 3, 8, 8, 650, 2, 348, 4294967295, 8, 8, 8, 652, 1, 4294967295, 4294967295, 1, 8, 32, 653, 1, 4294967295, 4294967295, 1, 8, 8, 654, 1, 4294967295, 4294967295, 3, 8, 8, 655, 2, 352, 4294967295, 8, 8, 8, 657, 1, 4294967295, 4294967295, 1, 8, 32, 658, 1, 4294967295, 4294967295, 1, 8, 8, 659, 1, 4294967295, 4294967295, 3, 8, 8, 660, 2, 356, 4294967295, 8, 8, 8, 662, 1, 4294967295, 4294967295, 1, 8, 32, 663, 1, 4294967295, 4294967295, 1, 8, 8, 664, 1, 4294967295, 4294967295, 3, 8, 8, 665, 2, 360, 4294967295, 8, 8, 8, 667, 1, 4294967295, 4294967295, 1, 8, 8, 668, 1, 4294967295, 4294967295, 1, 8, 8, 669, 1, 4294967295, 4294967295, 1, 9, 32, 670, 1, 4294967295, 4294967295, 1, 9, 8, 671, 1, 4294967295, 4294967295, 1, 9, 32, 672, 1, 4294967295, 4294967295, 1, 9, 8, 673, 1, 4294967295, 4294967295, 5, 9, 8, 674, 1, 368, 4294967295, 8, 9, 8, 675, 1, 4294967295, 4294967295, 10, 9, 8, 676, 2, 4294967295, 4294967295, 12, 9, 8, 678, 1, 4294967295, 371, 9, 9, 8, 679, 1, 4294967295, 4294967295, 1, 9, 32, 680, 1, 4294967295, 4294967295, 1, 9, 8, 681, 1, 4294967295, 4294967295, 1, 10, 8, 682, 1, 4294967295, 4294967295, 5, 10, 8, 683, 1, 376, 4294967295, 8, 10, 8, 684, 1, 4294967295, 4294967295, 10, 10, 8, 685, 2, 4294967295, 4294967295, 12, 10, 8, 687, 1, 4294967295, 379, 9, 10, 8, 688, 1, 4294967295, 4294967295, 1, 10, 8, 689, 1, 4294967295, 4294967295, 1, 10, 32, 690, 1, 4294967295, 4294967295, 1, 10, 8, 691, 1, 4294967295, 4294967295, 5, 10, 8, 692, 1, 384, 4294967295, 8, 10, 8, 693, 1, 4294967295, 4294967295, 10, 10, 8, 694, 2, 4294967295, 4294967295, 12, 10, 8, 696, 1, 4294967295, 387, 9, 10, 8, 697, 1, 4294967295, 4294967295, 1, 10, 8, 698, 1, 4294967295, 4294967295, 3, 10, 8, 699, 2, 390, 4294967295, 8, 10, 8, 701, 1, 4294967295, 4294967295, 1, 11, 8, 702, 1, 4294967295, 4294967295, 1, 11, 32, 703, 1, 4294967295, 4294967295, 1, 11, 8, 704, 1, 4294967295, 4294967295, 5, 11, 8, 705, 1, 395, 4294967295, 8, 11, 8, 706, 1, 4294967295, 4294967295, 10, 11, 8, 707, 2, 4294967295, 4294967295, 12, 11, 8, 709, 1, 4294967295, 398, 9, 11, 8, 710, 1, 4294967295, 4294967295, 1, 12, 32, 711, 1, 4294967295, 4294967295, 1, 12, 8, 712, 1, 4294967295, 4294967295, 1, 12, 32, 713, 1, 4294967295, 4294967295, 1, 12, 8, 714, 1, 4294967295, 4294967295, 3, 12, 8, 715, 2, 404, 4294967295, 8, 12, 8, 717, 1, 4294967295, 4294967295, 1, 12, 32, 718, 1, 4294967295, 4294967295, 1, 12, 8, 719, 1, 4294967295, 4294967295, 3, 12, 8, 720, 2, 408, 4294967295, 8, 12, 8, 722, 1, 4294967295, 4294967295, 1, 12, 32, 723, 1, 4294967295, 4294967295, 3, 12, 8, 724, 2, 411, 4294967295, 8, 12, 8, 726, 1, 4294967295, 4294967295, 1, 12, 8, 727, 1, 4294967295, 4294967295, 3, 12, 8, 728, 2, 414, 4294967295, 8, 12, 8, 730, 1, 4294967295, 4294967295, 1, 12, 32, 731, 1, 4294967295, 4294967295, 1, 12, 8, 732, 1, 4294967295, 4294967295, 1, 13, 8, 733, 1, 4294967295, 4294967295, 1, 13, 32, 734, 1, 4294967295, 4294967295, 1, 13, 8, 735, 1, 4294967295, 4294967295, 5, 13, 8, 736, 1, 421, 4294967295, 8, 13, 8, 737, 1, 4294967295, 4294967295, 10, 13, 8, 738, 2, 4294967295, 4294967295, 12, 13, 8, 740, 1, 4294967295, 424, 9, 13, 8, 741, 1, 4294967295, 4294967295, 1, 14, 8, 742, 1, 4294967295, 4294967295, 5, 14, 8, 743, 1, 427, 4294967295, 8, 14, 8, 744, 1, 4294967295, 4294967295, 10, 14, 8, 745, 2, 4294967295, 4294967295, 12, 14, 8, 747, 1, 4294967295, 430, 9, 14, 8, 748, 1, 4294967295, 4294967295, 1, 14, 8, 749, 1, 4294967295, 4294967295, 1, 14, 8, 750, 1, 4294967295, 4294967295, 3, 14, 8, 751, 2, 434, 4294967295, 8, 14, 8, 753, 1, 4294967295, 4294967295, 1, 14, 8, 754, 1, 4294967295, 4294967295, 3, 14, 8, 755, 2, 437, 4294967295, 8, 14, 8, 757, 1, 4294967295, 4294967295, 1, 15, 32, 758, 1, 4294967295, 4294967295, 1, 15, 8, 759, 1, 4294967295, 4294967295, 5, 15, 8, 760, 1, 441, 4294967295, 8, 15, 8, 761, 1, 4294967295, 4294967295, 10, 15, 8, 762, 2, 4294967295, 4294967295, 12, 15, 8, 764, 1, 4294967295, 444, 9, 15, 8, 765, 1, 4294967295, 4294967295, 1, 16, 32, 766, 1, 4294967295, 4294967295, 1, 16, 8, 767, 1, 4294967295, 4294967295, 1, 16, 8, 768, 1, 4294967295, 4294967295, 3, 16, 8, 769, 2, 449, 4294967295, 8, 16, 8, 771, 1, 4294967295, 4294967295, 1, 16, 32, 772, 1, 4294967295, 4294967295, 1, 16, 8, 773, 1, 4294967295, 4294967295, 3, 16, 8, 774, 2, 453, 4294967295, 8, 16, 8, 776, 1, 4294967295, 4294967295, 1, 16, 32, 777, 1, 4294967295, 4294967295, 1, 16, 8, 778, 1, 4294967295, 4294967295, 3, 16, 8, 779, 2, 457, 4294967295, 8, 16, 8, 781, 1, 4294967295, 4294967295, 1, 16, 8, 782, 1, 4294967295, 4294967295, 1, 16, 8, 783, 1, 4294967295, 4294967295, 1, 17, 32, 784, 1, 4294967295, 4294967295, 1, 17, 8, 785, 1, 4294967295, 4294967295, 5, 17, 8, 786, 1, 463, 4294967295, 8, 17, 8, 787, 1, 4294967295, 4294967295, 10, 17, 8, 788, 2, 4294967295, 4294967295, 12, 17, 8, 790, 1, 4294967295, 466, 9, 17, 8, 791, 1, 4294967295, 4294967295, 1, 17, 32, 792, 1, 4294967295, 4294967295, 1, 17, 8, 793, 1, 4294967295, 4294967295, 1, 18, 32, 794, 1, 4294967295, 4294967295, 1, 18, 8, 795, 1, 4294967295, 4294967295, 5, 18, 8, 796, 1, 472, 4294967295, 8, 18, 8, 797, 1, 4294967295, 4294967295, 10, 18, 8, 798, 2, 4294967295, 4294967295, 12, 18, 8, 800, 1, 4294967295, 475, 9, 18, 8, 801, 1, 4294967295, 4294967295, 1, 18, 32, 802, 1, 4294967295, 4294967295, 1, 18, 8, 803, 1, 4294967295, 4294967295, 1, 19, 32, 804, 1, 4294967295, 4294967295, 1, 19, 32, 805, 1, 4294967295, 4294967295, 3, 19, 8, 806, 2, 481, 4294967295, 8, 19, 8, 808, 1, 4294967295, 4294967295, 1, 19, 8, 809, 1, 4294967295, 4294967295, 1, 19, 8, 810, 1, 4294967295, 4294967295, 5, 19, 8, 811, 1, 485, 4294967295, 8, 19, 8, 812, 1, 4294967295, 4294967295, 10, 19, 8, 813, 2, 4294967295, 4294967295, 12, 19, 8, 815, 1, 4294967295, 488, 9, 19, 8, 816, 1, 4294967295, 4294967295, 1, 19, 8, 817, 1, 4294967295, 4294967295, 3, 19, 8, 818, 3, 491, 4294967295, 8, 19, 8, 821, 1, 4294967295, 4294967295, 1, 20, 8, 822, 1, 4294967295, 4294967295, 1, 20, 8, 823, 1, 4294967295, 4294967295, 1, 20, 8, 824, 1, 4294967295, 4294967295, 1, 20, 8, 825, 1, 4294967295, 4294967295, 1, 20, 8, 826, 1, 4294967295, 4294967295, 1, 20, 8, 827, 1, 4294967295, 4294967295, 1, 20, 8, 828, 1, 4294967295, 4294967295, 1, 20, 8, 829, 1, 4294967295, 4294967295, 1, 20, 8, 830, 1, 4294967295, 4294967295, 1, 20, 8, 831, 1, 4294967295, 4294967295, 3, 20, 8, 832, 10, 503, 4294967295, 8, 20, 8, 842, 1, 4294967295, 4294967295, 1, 21, 8, 843, 1, 4294967295, 4294967295, 1, 21, 8, 844, 1, 4294967295, 4294967295, 1, 21, 8, 845, 1, 4294967295, 4294967295, 1, 21, 32, 846, 1, 4294967295, 4294967295, 1, 21, 32, 847, 1, 4294967295, 4294967295, 5, 21, 8, 848, 1, 510, 4294967295, 8, 21, 8, 849, 1, 4294967295, 4294967295, 10, 21, 8, 850, 2, 4294967295, 4294967295, 12, 21, 8, 852, 1, 4294967295, 513, 9, 21, 8, 853, 1, 4294967295, 4294967295, 1, 21, 32, 854, 1, 4294967295, 4294967295, 1, 21, 8, 855, 1, 4294967295, 4294967295, 3, 21, 8, 856, 2, 517, 4294967295, 8, 21, 8, 858, 1, 4294967295, 4294967295, 1, 21, 8, 859, 1, 4294967295, 4294967295, 1, 21, 8, 860, 1, 4294967295, 4294967295, 1, 22, 8, 861, 1, 4294967295, 4294967295, 1, 22, 32, 862, 1, 4294967295, 4294967295, 3, 22, 8, 863, 2, 523, 4294967295, 8, 22, 8, 865, 1, 4294967295, 4294967295, 1, 23, 8, 866, 1, 4294967295, 4294967295, 1, 23, 32, 867, 1, 4294967295, 4294967295, 3, 23, 8, 868, 2, 527, 4294967295, 8, 23, 8, 870, 1, 4294967295, 4294967295, 1, 24, 8, 871, 1, 4294967295, 4294967295, 1, 24, 8, 872, 1, 4294967295, 4294967295, 1, 24, 8, 873, 1, 4294967295, 4294967295, 1, 25, 8, 874, 1, 4294967295, 4294967295, 1, 25, 8, 875, 1, 4294967295, 4294967295, 1, 25, 8, 876, 1, 4294967295, 4294967295, 1, 26, 8, 877, 1, 4294967295, 4294967295, 1, 26, 8, 878, 1, 4294967295, 4294967295, 1, 26, 32, 879, 1, 4294967295, 4294967295, 1, 26, 8, 880, 1, 4294967295, 4294967295, 3, 26, 8, 881, 2, 539, 4294967295, 8, 26, 8, 883, 1, 4294967295, 4294967295, 1, 26, 8, 884, 1, 4294967295, 4294967295, 1, 26, 8, 885, 1, 4294967295, 4294967295, 1, 27, 8, 886, 1, 4294967295, 4294967295, 5, 27, 8, 887, 1, 544, 4294967295, 8, 27, 8, 888, 1, 4294967295, 4294967295, 10, 27, 8, 889, 2, 4294967295, 4294967295, 12, 27, 8, 891, 1, 4294967295, 547, 9, 27, 8, 892, 1, 4294967295, 4294967295, 1, 27, 8, 893, 1, 4294967295, 4294967295, 1, 27, 8, 894, 1, 4294967295, 4294967295, 1, 27, 8, 895, 1, 4294967295, 4294967295, 1, 28, 8, 896, 1, 4294967295, 4294967295, 1, 28, 8, 897, 1, 4294967295, 4294967295, 1, 28, 32, 898, 1, 4294967295, 4294967295, 1, 28, 8, 899, 1, 4294967295, 4294967295, 1, 29, 8, 900, 1, 4294967295, 4294967295, 5, 29, 8, 901, 1, 557, 4294967295, 8, 29, 8, 902, 1, 4294967295, 4294967295, 10, 29, 8, 903, 2, 4294967295, 4294967295, 12, 29, 8, 905, 1, 4294967295, 560, 9, 29, 8, 906, 1, 4294967295, 4294967295, 1, 29, 8, 907, 1, 4294967295, 4294967295, 1, 29, 32, 908, 1, 4294967295, 4294967295, 3, 29, 8, 909, 2, 564, 4294967295, 8, 29, 8, 911, 1, 4294967295, 4294967295, 1, 30, 8, 912, 1, 4294967295, 4294967295, 1, 30, 8, 913, 1, 4294967295, 4294967295, 1, 30, 8, 914, 1, 4294967295, 4294967295, 1, 30, 8, 915, 1, 4294967295, 4294967295, 1, 30, 8, 916, 1, 4294967295, 4294967295, 1, 30, 8, 917, 1, 4294967295, 4294967295, 1, 30, 8, 918, 1, 4294967295, 4294967295, 1, 30, 8, 919, 1, 4294967295, 4294967295, 3, 30, 8, 920, 8, 574, 4294967295, 8, 30, 8, 928, 1, 4294967295, 4294967295, 1, 31, 8, 929, 1, 4294967295, 4294967295, 1, 31, 8, 930, 1, 4294967295, 4294967295, 1, 31, 32, 931, 1, 4294967295, 4294967295, 1, 31, 8, 932, 1, 4294967295, 4294967295, 5, 31, 8, 933, 1, 580, 4294967295, 8, 31, 8, 934, 1, 4294967295, 4294967295, 10, 31, 8, 935, 2, 4294967295, 4294967295, 12, 31, 8, 937, 1, 4294967295, 583, 9, 31, 8, 938, 1, 4294967295, 4294967295, 1, 31, 32, 939, 1, 4294967295, 4294967295, 1, 31, 8, 940, 1, 4294967295, 4294967295, 1, 32, 8, 941, 1, 4294967295, 4294967295, 1, 32, 32, 942, 1, 4294967295, 4294967295, 1, 32, 32, 943, 1, 4294967295, 4294967295, 5, 32, 8, 944, 1, 590, 4294967295, 8, 32, 8, 945, 1, 4294967295, 4294967295, 10, 32, 8, 946, 2, 4294967295, 4294967295, 12, 32, 8, 948, 1, 4294967295, 593, 9, 32, 8, 949, 1, 4294967295, 4294967295, 1, 32, 32, 950, 1, 4294967295, 4294967295, 1, 32, 8, 951, 1, 4294967295, 4294967295, 1, 32, 8, 952, 1, 4294967295, 4294967295, 1, 33, 8, 953, 1, 4294967295, 4294967295, 5, 33, 8, 954, 1, 599, 4294967295, 8, 33, 8, 955, 1, 4294967295, 4294967295, 10, 33, 8, 956, 2, 4294967295, 4294967295, 12, 33, 8, 958, 1, 4294967295, 602, 9, 33, 8, 959, 1, 4294967295, 4294967295, 1, 33, 8, 960, 1, 4294967295, 4294967295, 1, 33, 8, 961, 1, 4294967295, 4294967295, 1, 34, 8, 962, 1, 4294967295, 4294967295, 1, 34, 32, 963, 1, 4294967295, 4294967295, 1, 34, 32, 964, 1, 4294967295, 4294967295, 1, 34, 32, 965, 1, 4294967295, 4294967295, 1, 34, 32, 966, 1, 4294967295, 4294967295, 1, 34, 32, 967, 1, 4294967295, 4294967295, 3, 34, 8, 968, 6, 612, 4294967295, 8, 34, 8, 974, 1, 4294967295, 4294967295, 1, 35, 8, 975, 1, 4294967295, 4294967295, 5, 35, 8, 976, 1, 615, 4294967295, 8, 35, 8, 977, 1, 4294967295, 4294967295, 10, 35, 8, 978, 2, 4294967295, 4294967295, 12, 35, 8, 980, 1, 4294967295, 618, 9, 35, 8, 981, 1, 4294967295, 4294967295, 1, 35, 8, 982, 1, 4294967295, 4294967295, 1, 35, 8, 983, 1, 4294967295, 4294967295, 1, 35, 8, 984, 1, 4294967295, 4294967295, 1, 36, 8, 985, 1, 4294967295, 4294967295, 5, 36, 8, 986, 1, 624, 4294967295, 8, 36, 8, 987, 1, 4294967295, 4294967295, 10, 36, 8, 988, 2, 4294967295, 4294967295, 12, 36, 8, 990, 1, 4294967295, 627, 9, 36, 8, 991, 1, 4294967295, 4294967295, 1, 36, 8, 992, 1, 4294967295, 4294967295, 1, 36, 8, 993, 1, 4294967295, 4294967295, 1, 36, 8, 994, 1, 4294967295, 4294967295, 1, 36, 32, 995, 1, 4294967295, 4294967295, 1, 36, 32, 996, 1, 4294967295, 4294967295, 5, 36, 8, 997, 1, 634, 4294967295, 8, 36, 8, 998, 1, 4294967295, 4294967295, 10, 36, 8, 999, 2, 4294967295, 4294967295, 12, 36, 8, 1001, 1, 4294967295, 637, 9, 36, 8, 1002, 1, 4294967295, 4294967295, 1, 36, 32, 1003, 1, 4294967295, 4294967295, 1, 36, 8, 1004, 1, 4294967295, 4294967295, 3, 36, 8, 1005, 2, 641, 4294967295, 8, 36, 8, 1007, 1, 4294967295, 4294967295, 1, 36, 8, 1008, 1, 4294967295, 4294967295, 1, 36, 8, 1009, 1, 4294967295, 4294967295, 1, 37, 8, 1010, 1, 4294967295, 4294967295, 1, 37, 32, 1011, 1, 4294967295, 4294967295, 1, 37, 8, 1012, 1, 4294967295, 4294967295, 5, 37, 8, 1013, 1, 648, 4294967295, 8, 37, 8, 1014, 1, 4294967295, 4294967295, 10, 37, 8, 1015, 2, 4294967295, 4294967295, 12, 37, 8, 1017, 1, 4294967295, 651, 9, 37, 8, 1018, 1, 4294967295, 4294967295, 1, 38, 8, 1019, 1, 4294967295, 4294967295, 1, 38, 32, 1020, 1, 4294967295, 4294967295, 1, 38, 8, 1021, 1, 4294967295, 4294967295, 3, 38, 8, 1022, 2, 656, 4294967295, 8, 38, 8, 1024, 1, 4294967295, 4294967295, 1, 39, 8, 1025, 1, 4294967295, 4294967295, 1, 39, 32, 1026, 1, 4294967295, 4294967295, 1, 39, 32, 1027, 1, 4294967295, 4294967295, 5, 39, 8, 1028, 1, 661, 4294967295, 8, 39, 8, 1029, 1, 4294967295, 4294967295, 10, 39, 8, 1030, 2, 4294967295, 4294967295, 12, 39, 8, 1032, 1, 4294967295, 664, 9, 39, 8, 1033, 1, 4294967295, 4294967295, 1, 40, 8, 1034, 1, 4294967295, 4294967295, 1, 40, 8, 1035, 1, 4294967295, 4294967295, 3, 40, 8, 1036, 2, 668, 4294967295, 8, 40, 8, 1038, 1, 4294967295, 4294967295, 1, 41, 32, 1039, 1, 4294967295, 4294967295, 1, 41, 8, 1040, 1, 4294967295, 4294967295, 1, 41, 32, 1041, 1, 4294967295, 4294967295, 1, 41, 8, 1042, 1, 4294967295, 4294967295, 5, 41, 8, 1043, 1, 674, 4294967295, 8, 41, 8, 1044, 1, 4294967295, 4294967295, 10, 41, 8, 1045, 2, 4294967295, 4294967295, 12, 41, 8, 1047, 1, 4294967295, 677, 9, 41, 8, 1048, 1, 4294967295, 4294967295, 1, 41, 32, 1049, 1, 4294967295, 4294967295, 3, 41, 8, 1050, 2, 680, 4294967295, 8, 41, 8, 1052, 1, 4294967295, 4294967295, 3, 41, 8, 1053, 2, 682, 4294967295, 8, 41, 8, 1055, 1, 4294967295, 4294967295, 1, 41, 32, 1056, 1, 4294967295, 4294967295, 1, 41, 8, 1057, 1, 4294967295, 4294967295, 1, 42, 8, 1058, 1, 4294967295, 4294967295, 1, 42, 32, 1059, 1, 4294967295, 4294967295, 1, 42, 8, 1060, 1, 4294967295, 4294967295, 5, 42, 8, 1061, 1, 689, 4294967295, 8, 42, 8, 1062, 1, 4294967295, 4294967295, 10, 42, 8, 1063, 2, 4294967295, 4294967295, 12, 42, 8, 1065, 1, 4294967295, 692, 9, 42, 8, 1066, 1, 4294967295, 4294967295, 3, 42, 8, 1067, 2, 694, 4294967295, 8, 42, 8, 1069, 1, 4294967295, 4294967295, 1, 42, 8, 1070, 1, 4294967295, 4294967295, 1, 42, 8, 1071, 1, 4294967295, 4294967295, 3, 42, 8, 1072, 2, 698, 4294967295, 8, 42, 8, 1074, 1, 4294967295, 4294967295, 4, 42, 8, 1075, 1, 700, 4294967295, 8, 42, 8, 1076, 1, 4294967295, 4294967295, 11, 42, 8, 1077, 2, 4294967295, 4294967295, 12, 42, 8, 1079, 1, 4294967295, 701, 1, 42, 32, 1080, 1, 4294967295, 4294967295, 1, 42, 8, 1081, 1, 4294967295, 4294967295, 5, 42, 8, 1082, 1, 706, 4294967295, 8, 42, 8, 1083, 1, 4294967295, 4294967295, 10, 42, 8, 1084, 2, 4294967295, 4294967295, 12, 42, 8, 1086, 1, 4294967295, 709, 9, 42, 8, 1087, 1, 4294967295, 4294967295, 1, 42, 8, 1088, 1, 4294967295, 4294967295, 1, 42, 8, 1089, 1, 4294967295, 4294967295, 3, 42, 8, 1090, 2, 713, 4294967295, 8, 42, 8, 1092, 1, 4294967295, 4294967295, 5, 42, 8, 1093, 1, 715, 4294967295, 8, 42, 8, 1094, 1, 4294967295, 4294967295, 10, 42, 8, 1095, 2, 4294967295, 4294967295, 12, 42, 8, 1097, 1, 4294967295, 718, 9, 42, 8, 1098, 1, 4294967295, 4294967295, 1, 43, 8, 1099, 1, 4294967295, 4294967295, 1, 43, 32, 1100, 1, 4294967295, 4294967295, 1, 43, 8, 1101, 1, 4294967295, 4294967295, 5, 43, 8, 1102, 1, 723, 4294967295, 8, 43, 8, 1103, 1, 4294967295, 4294967295, 10, 43, 8, 1104, 2, 4294967295, 4294967295, 12, 43, 8, 1106, 1, 4294967295, 726, 9, 43, 8, 1107, 1, 4294967295, 4294967295, 1, 44, 8, 1108, 1, 4294967295, 4294967295, 1, 44, 8, 1109, 1, 4294967295, 4294967295, 5, 44, 8, 1110, 1, 730, 4294967295, 8, 44, 8, 1111, 1, 4294967295, 4294967295, 10, 44, 8, 1112, 2, 4294967295, 4294967295, 12, 44, 8, 1114, 1, 4294967295, 733, 9, 44, 8, 1115, 1, 4294967295, 4294967295, 1, 44, 32, 1116, 1, 4294967295, 4294967295, 1, 44, 32, 1117, 1, 4294967295, 4294967295, 1, 44, 8, 1118, 1, 4294967295, 4294967295, 3, 44, 8, 1119, 2, 738, 4294967295, 8, 44, 8, 1121, 1, 4294967295, 4294967295, 3, 44, 8, 1122, 2, 740, 4294967295, 8, 44, 8, 1124, 1, 4294967295, 4294967295, 1, 45, 8, 1125, 1, 4294967295, 4294967295, 1, 45, 32, 1126, 1, 4294967295, 4294967295, 1, 45, 8, 1127, 1, 4294967295, 4294967295, 5, 45, 8, 1128, 1, 745, 4294967295, 8, 45, 8, 1129, 1, 4294967295, 4294967295, 10, 45, 8, 1130, 2, 4294967295, 4294967295, 12, 45, 8, 1132, 1, 4294967295, 748, 9, 45, 8, 1133, 1, 4294967295, 4294967295, 1, 46, 32, 1134, 1, 4294967295, 4294967295, 1, 46, 8, 1135, 1, 4294967295, 4294967295, 1, 46, 8, 1136, 1, 4294967295, 4294967295, 3, 46, 8, 1137, 2, 753, 4294967295, 8, 46, 8, 1139, 1, 4294967295, 4294967295, 1, 46, 32, 1140, 1, 4294967295, 4294967295, 1, 46, 8, 1141, 1, 4294967295, 4294967295, 5, 46, 8, 1142, 1, 757, 4294967295, 8, 46, 8, 1143, 1, 4294967295, 4294967295, 10, 46, 8, 1144, 2, 4294967295, 4294967295, 12, 46, 8, 1146, 1, 4294967295, 760, 9, 46, 8, 1147, 1, 4294967295, 4294967295, 3, 46, 8, 1148, 2, 762, 4294967295, 8, 46, 8, 1150, 1, 4294967295, 4294967295, 1, 46, 32, 1151, 1, 4294967295, 4294967295, 1, 46, 8, 1152, 1, 4294967295, 4294967295, 1, 47, 8, 1153, 1, 4294967295, 4294967295, 1, 47, 8, 1154, 1, 4294967295, 4294967295, 1, 47, 32, 1155, 1, 4294967295, 4294967295, 1, 47, 8, 1156, 1, 4294967295, 4294967295, 5, 47, 8, 1157, 1, 770, 4294967295, 8, 47, 8, 1158, 1, 4294967295, 4294967295, 10, 47, 8, 1159, 2, 4294967295, 4294967295, 12, 47, 8, 1161, 1, 4294967295, 773, 9, 47, 8, 1162, 1, 4294967295, 4294967295, 1, 47, 32, 1163, 1, 4294967295, 4294967295, 1, 47, 8, 1164, 1, 4294967295, 4294967295, 1, 48, 8, 1165, 1, 4294967295, 4294967295, 1, 48, 32, 1166, 1, 4294967295, 4294967295, 1, 48, 8, 1167, 1, 4294967295, 4294967295, 5, 48, 8, 1168, 1, 780, 4294967295, 8, 48, 8, 1169, 1, 4294967295, 4294967295, 10, 48, 8, 1170, 2, 4294967295, 4294967295, 12, 48, 8, 1172, 1, 4294967295, 783, 9, 48, 8, 1173, 1, 4294967295, 4294967295, 1, 49, 8, 1174, 1, 4294967295, 4294967295, 5, 49, 8, 1175, 1, 786, 4294967295, 8, 49, 8, 1176, 1, 4294967295, 4294967295, 10, 49, 8, 1177, 2, 4294967295, 4294967295, 12, 49, 8, 1179, 1, 4294967295, 789, 9, 49, 8, 1180, 1, 4294967295, 4294967295, 1, 49, 8, 1181, 1, 4294967295, 4294967295, 1, 49, 8, 1182, 1, 4294967295, 4294967295, 5, 49, 8, 1183, 1, 793, 4294967295, 8, 49, 8, 1184, 1, 4294967295, 4294967295, 10, 49, 8, 1185, 2, 4294967295, 4294967295, 12, 49, 8, 1187, 1, 4294967295, 796, 9, 49, 8, 1188, 1, 4294967295, 4294967295, 1, 49, 32, 1189, 1, 4294967295, 4294967295, 3, 49, 8, 1190, 2, 799, 4294967295, 8, 49, 8, 1192, 1, 4294967295, 4294967295, 1, 49, 8, 1193, 1, 4294967295, 4294967295, 1, 49, 8, 1194, 1, 4294967295, 4294967295, 1, 50, 8, 1195, 1, 4294967295, 4294967295, 1, 50, 32, 1196, 1, 4294967295, 4294967295, 1, 50, 8, 1197, 1, 4294967295, 4294967295, 5, 50, 8, 1198, 1, 806, 4294967295, 8, 50, 8, 1199, 1, 4294967295, 4294967295, 10, 50, 8, 1200, 2, 4294967295, 4294967295, 12, 50, 8, 1202, 1, 4294967295, 809, 9, 50, 8, 1203, 1, 4294967295, 4294967295, 1, 51, 8, 1204, 1, 4294967295, 4294967295, 5, 51, 8, 1205, 1, 812, 4294967295, 8, 51, 8, 1206, 1, 4294967295, 4294967295, 10, 51, 8, 1207, 2, 4294967295, 4294967295, 12, 51, 8, 1209, 1, 4294967295, 815, 9, 51, 8, 1210, 1, 4294967295, 4294967295, 1, 51, 32, 1211, 1, 4294967295, 4294967295, 1, 51, 8, 1212, 1, 4294967295, 4294967295, 1, 51, 8, 1213, 1, 4294967295, 4294967295, 1, 52, 8, 1214, 1, 4294967295, 4294967295, 1, 52, 32, 1215, 1, 4294967295, 4294967295, 1, 52, 8, 1216, 1, 4294967295, 4294967295, 5, 52, 8, 1217, 1, 823, 4294967295, 8, 52, 8, 1218, 1, 4294967295, 4294967295, 10, 52, 8, 1219, 2, 4294967295, 4294967295, 12, 52, 8, 1221, 1, 4294967295, 826, 9, 52, 8, 1222, 1, 4294967295, 4294967295, 1, 53, 8, 1223, 1, 4294967295, 4294967295, 1, 53, 8, 1224, 1, 4294967295, 4294967295, 1, 53, 32, 1225, 1, 4294967295, 4294967295, 1, 53, 32, 1226, 1, 4294967295, 4294967295, 1, 53, 32, 1227, 1, 4294967295, 4294967295, 1, 53, 32, 1228, 1, 4294967295, 4294967295, 1, 53, 32, 1229, 1, 4294967295, 4294967295, 3, 53, 8, 1230, 7, 835, 4294967295, 8, 53, 8, 1237, 1, 4294967295, 4294967295, 1, 54, 32, 1238, 1, 4294967295, 4294967295, 1, 54, 8, 1239, 1, 4294967295, 4294967295, 1, 55, 32, 1240, 1, 4294967295, 4294967295, 1, 55, 8, 1241, 1, 4294967295, 4294967295, 1, 56, 32, 1242, 1, 4294967295, 4294967295, 1, 56, 8, 1243, 1, 4294967295, 4294967295, 1, 56, 8, 1244, 1, 4294967295, 4294967295, 1, 56, 8, 1245, 1, 4294967295, 4294967295, 3, 56, 8, 1246, 2, 845, 4294967295, 8, 56, 8, 1248, 1, 4294967295, 4294967295, 1, 57, 32, 1249, 1, 4294967295, 4294967295, 1, 57, 8, 1250, 1, 4294967295, 4294967295, 1, 57, 32, 1251, 1, 4294967295, 4294967295, 1, 57, 8, 1252, 1, 4294967295, 4294967295, 5, 57, 8, 1253, 1, 851, 4294967295, 8, 57, 8, 1254, 1, 4294967295, 4294967295, 10, 57, 8, 1255, 2, 4294967295, 4294967295, 12, 57, 8, 1257, 1, 4294967295, 854, 9, 57, 8, 1258, 1, 4294967295, 4294967295, 3, 57, 8, 1259, 2, 856, 4294967295, 8, 57, 8, 1261, 1, 4294967295, 4294967295, 1, 57, 32, 1262, 1, 4294967295, 4294967295, 1, 57, 8, 1263, 1, 4294967295, 4294967295, 1, 58, 72, 1264, 1, 4294967295, 4294967295, 1, 58, 8, 1265, 1, 4294967295, 4294967295, 1, 58, 8, 1266, 1, 4294967295, 4294967295, 1, 58, 32, 1267, 1, 4294967295, 4294967295, 1, 58, 8, 1268, 1, 4294967295, 4294967295, 1, 58, 8, 1269, 1, 4294967295, 4294967295, 3, 58, 8, 1270, 2, 866, 4294967295, 8, 58, 8, 1272, 1, 4294967295, 4294967295, 1, 59, 8, 1273, 1, 4294967295, 4294967295, 1, 59, 8, 1274, 1, 4294967295, 4294967295, 1, 59, 32, 1275, 1, 4294967295, 4294967295, 1, 59, 8, 1276, 1, 4294967295, 4294967295, 1, 59, 32, 1277, 1, 4294967295, 4294967295, 1, 59, 8, 1278, 1, 4294967295, 4294967295, 5, 59, 8, 1279, 1, 874, 4294967295, 8, 59, 8, 1280, 1, 4294967295, 4294967295, 10, 59, 8, 1281, 2, 4294967295, 4294967295, 12, 59, 8, 1283, 1, 4294967295, 877, 9, 59, 8, 1284, 1, 4294967295, 4294967295, 3, 59, 8, 1285, 2, 879, 4294967295, 8, 59, 8, 1287, 1, 4294967295, 4294967295, 1, 59, 32, 1288, 1, 4294967295, 4294967295, 3, 59, 8, 1289, 2, 882, 4294967295, 8, 59, 8, 1291, 1, 4294967295, 4294967295, 1, 59, 32, 1292, 1, 4294967295, 4294967295, 3, 59, 8, 1293, 3, 885, 4294967295, 8, 59, 8, 1296, 1, 4294967295, 4294967295, 1, 60, 8, 1297, 1, 4294967295, 4294967295, 1, 60, 8, 1298, 1, 4294967295, 4294967295, 1, 60, 8, 1299, 1, 4294967295, 4294967295, 3, 60, 8, 1300, 3, 890, 4294967295, 8, 60, 8, 1303, 1, 4294967295, 4294967295, 1, 61, 32, 1304, 1, 4294967295, 4294967295, 1, 61, 8, 1305, 1, 4294967295, 4294967295, 1, 61, 32, 1306, 1, 4294967295, 4294967295, 1, 61, 8, 1307, 1, 4294967295, 4294967295, 5, 61, 8, 1308, 1, 896, 4294967295, 8, 61, 8, 1309, 1, 4294967295, 4294967295, 10, 61, 8, 1310, 2, 4294967295, 4294967295, 12, 61, 8, 1312, 1, 4294967295, 899, 9, 61, 8, 1313, 1, 4294967295, 4294967295, 3, 61, 8, 1314, 2, 901, 4294967295, 8, 61, 8, 1316, 1, 4294967295, 4294967295, 1, 61, 32, 1317, 1, 4294967295, 4294967295, 3, 61, 8, 1318, 2, 904, 4294967295, 8, 61, 8, 1320, 1, 4294967295, 4294967295, 1, 61, 32, 1321, 1, 4294967295, 4294967295, 1, 61, 8, 1322, 1, 4294967295, 4294967295, 1, 62, 32, 1323, 1, 4294967295, 4294967295, 1, 62, 32, 1324, 1, 4294967295, 4294967295, 1, 62, 8, 1325, 1, 4294967295, 4294967295, 1, 62, 8, 1326, 1, 4294967295, 4294967295, 1, 62, 8, 1327, 1, 4294967295, 4294967295, 1, 63, 32, 1328, 1, 4294967295, 4294967295, 1, 63, 8, 1329, 1, 4294967295, 4294967295, 5, 63, 8, 1330, 1, 915, 4294967295, 8, 63, 8, 1331, 1, 4294967295, 4294967295, 10, 63, 8, 1332, 2, 4294967295, 4294967295, 12, 63, 8, 1334, 1, 4294967295, 918, 9, 63, 8, 1335, 1, 4294967295, 4294967295, 1, 63, 32, 1336, 1, 4294967295, 4294967295, 1, 63, 8, 1337, 1, 4294967295, 4294967295, 1, 64, 8, 1338, 1, 4294967295, 4294967295, 5, 64, 8, 1339, 1, 923, 4294967295, 8, 64, 8, 1340, 1, 4294967295, 4294967295, 10, 64, 8, 1341, 2, 4294967295, 4294967295, 12, 64, 8, 1343, 1, 4294967295, 926, 9, 64, 8, 1344, 1, 4294967295, 4294967295, 1, 64, 8, 1345, 1, 4294967295, 4294967295, 1, 64, 32, 1346, 1, 4294967295, 4294967295, 3, 64, 8, 1347, 2, 930, 4294967295, 8, 64, 8, 1349, 1, 4294967295, 4294967295, 1, 65, 8, 1350, 1, 4294967295, 4294967295, 1, 65, 8, 1351, 1, 4294967295, 4294967295, 1, 65, 32, 1352, 1, 4294967295, 4294967295, 1, 65, 8, 1353, 1, 4294967295, 4294967295, 1, 65, 8, 1354, 1, 4294967295, 4294967295, 1, 65, 32, 1355, 1, 4294967295, 4294967295, 3, 65, 8, 1356, 2, 938, 4294967295, 8, 65, 8, 1358, 1, 4294967295, 4294967295, 1, 65, 8, 1359, 1, 4294967295, 4294967295, 1, 65, 32, 1360, 1, 4294967295, 4294967295, 3, 65, 8, 1361, 2, 942, 4294967295, 8, 65, 8, 1363, 1, 4294967295, 4294967295, 1, 65, 8, 1364, 1, 4294967295, 4294967295, 1, 65, 32, 1365, 1, 4294967295, 4294967295, 3, 65, 8, 1366, 2, 946, 4294967295, 8, 65, 8, 1368, 1, 4294967295, 4294967295, 1, 65, 8, 1369, 1, 4294967295, 4294967295, 1, 65, 32, 1370, 1, 4294967295, 4294967295, 3, 65, 8, 1371, 2, 950, 4294967295, 8, 65, 8, 1373, 1, 4294967295, 4294967295, 1, 65, 8, 1374, 1, 4294967295, 4294967295, 1, 65, 32, 1375, 1, 4294967295, 4294967295, 3, 65, 8, 1376, 2, 954, 4294967295, 8, 65, 8, 1378, 1, 4294967295, 4294967295, 3, 65, 8, 1379, 6, 956, 4294967295, 8, 65, 8, 1385, 1, 4294967295, 4294967295, 1, 66, 8, 1386, 1, 4294967295, 4294967295, 1, 66, 8, 1387, 1, 4294967295, 4294967295, 3, 66, 8, 1388, 2, 960, 4294967295, 8, 66, 8, 1390, 1, 4294967295, 4294967295, 1, 67, 8, 1391, 1, 4294967295, 4294967295, 1, 67, 32, 1392, 1, 4294967295, 4294967295, 1, 67, 32, 1393, 1, 4294967295, 4294967295, 1, 67, 8, 1394, 1, 4294967295, 4294967295, 3, 67, 8, 1395, 2, 966, 4294967295, 8, 67, 8, 1397, 1, 4294967295, 4294967295, 1, 68, 8, 1398, 1, 4294967295, 4294967295, 1, 68, 8, 1399, 1, 4294967295, 4294967295, 1, 69, 32, 1400, 1, 4294967295, 4294967295, 1, 69, 8, 1401, 1, 4294967295, 4294967295, 1, 69, 8, 1402, 1, 4294967295, 4294967295, 1, 70, 8, 1403, 1, 4294967295, 4294967295, 5, 70, 8, 1404, 1, 974, 4294967295, 8, 70, 8, 1405, 1, 4294967295, 4294967295, 10, 70, 8, 1406, 2, 4294967295, 4294967295, 12, 70, 8, 1408, 1, 4294967295, 977, 9, 70, 8, 1409, 1, 4294967295, 4294967295, 1, 70, 32, 1410, 1, 4294967295, 4294967295, 3, 70, 8, 1411, 2, 980, 4294967295, 8, 70, 8, 1413, 1, 4294967295, 4294967295, 1, 70, 32, 1414, 1, 4294967295, 4294967295, 1, 70, 8, 1415, 1, 4294967295, 4294967295, 1, 70, 32, 1416, 1, 4294967295, 4294967295, 1, 70, 8, 1417, 1, 4294967295, 4294967295, 5, 70, 8, 1418, 1, 986, 4294967295, 8, 70, 8, 1419, 1, 4294967295, 4294967295, 10, 70, 8, 1420, 2, 4294967295, 4294967295, 12, 70, 8, 1422, 1, 4294967295, 989, 9, 70, 8, 1423, 1, 4294967295, 4294967295, 1, 70, 32, 1424, 1, 4294967295, 4294967295, 1, 70, 8, 1425, 1, 4294967295, 4294967295, 1, 71, 32, 1426, 1, 4294967295, 4294967295, 1, 71, 8, 1427, 1, 4294967295, 4294967295, 5, 71, 8, 1428, 1, 995, 4294967295, 8, 71, 8, 1429, 1, 4294967295, 4294967295, 10, 71, 8, 1430, 2, 4294967295, 4294967295, 12, 71, 8, 1432, 1, 4294967295, 998, 9, 71, 8, 1433, 1, 4294967295, 4294967295, 1, 71, 8, 1434, 1, 4294967295, 4294967295, 1, 71, 32, 1435, 1, 4294967295, 4294967295, 1, 71, 8, 1436, 1, 4294967295, 4294967295, 1, 71, 32, 1437, 1, 4294967295, 4294967295, 1, 71, 8, 1438, 1, 4294967295, 4294967295, 1, 71, 32, 1439, 1, 4294967295, 4294967295, 1, 71, 8, 1440, 1, 4294967295, 4294967295, 1, 71, 32, 1441, 1, 4294967295, 4294967295, 1, 71, 8, 1442, 1, 4294967295, 4294967295, 5, 71, 8, 1443, 1, 1009, 4294967295, 8, 71, 8, 1444, 1, 4294967295, 4294967295, 10, 71, 8, 1445, 2, 4294967295, 4294967295, 12, 71, 8, 1447, 1, 4294967295, 1012, 9, 71, 8, 1448, 1, 4294967295, 4294967295, 3, 71, 8, 1449, 2, 1014, 4294967295, 8, 71, 8, 1451, 1, 4294967295, 4294967295, 1, 71, 32, 1452, 1, 4294967295, 4294967295, 1, 71, 8, 1453, 1, 4294967295, 4294967295, 1, 71, 32, 1454, 1, 4294967295, 4294967295, 1, 71, 8, 1455, 1, 4294967295, 4294967295, 1, 71, 32, 1456, 1, 4294967295, 4294967295, 1, 71, 8, 1457, 1, 4294967295, 4294967295, 1, 71, 32, 1458, 1, 4294967295, 4294967295, 1, 71, 8, 1459, 1, 4294967295, 4294967295, 5, 71, 8, 1460, 1, 1024, 4294967295, 8, 71, 8, 1461, 1, 4294967295, 4294967295, 10, 71, 8, 1462, 2, 4294967295, 4294967295, 12, 71, 8, 1464, 1, 4294967295, 1027, 9, 71, 8, 1465, 1, 4294967295, 4294967295, 3, 71, 8, 1466, 2, 1029, 4294967295, 8, 71, 8, 1468, 1, 4294967295, 4294967295, 1, 71, 32, 1469, 1, 4294967295, 4294967295, 1, 71, 8, 1470, 1, 4294967295, 4294967295, 1, 71, 32, 1471, 1, 4294967295, 4294967295, 1, 71, 8, 1472, 1, 4294967295, 4294967295, 1, 71, 32, 1473, 1, 4294967295, 4294967295, 1, 71, 8, 1474, 1, 4294967295, 4294967295, 1, 71, 32, 1475, 1, 4294967295, 4294967295, 1, 71, 8, 1476, 1, 4294967295, 4294967295, 1, 71, 32, 1477, 1, 4294967295, 4294967295, 1, 71, 8, 1478, 1, 4294967295, 4294967295, 1, 71, 32, 1479, 1, 4294967295, 4294967295, 1, 71, 8, 1480, 1, 4294967295, 4294967295, 5, 71, 8, 1481, 1, 1043, 4294967295, 8, 71, 8, 1482, 1, 4294967295, 4294967295, 10, 71, 8, 1483, 2, 4294967295, 4294967295, 12, 71, 8, 1485, 1, 4294967295, 1046, 9, 71, 8, 1486, 1, 4294967295, 4294967295, 1, 71, 32, 1487, 1, 4294967295, 4294967295, 1, 71, 8, 1488, 1, 4294967295, 4294967295, 3, 71, 8, 1489, 5, 1050, 4294967295, 8, 71, 8, 1494, 1, 4294967295, 4294967295, 1, 72, 32, 1495, 1, 4294967295, 4294967295, 1, 72, 8, 1496, 1, 4294967295, 4294967295, 1, 73, 32, 1497, 1, 4294967295, 4294967295, 1, 73, 8, 1498, 1, 4294967295, 4294967295, 1, 73, 8, 1499, 1, 4294967295, 4294967295, 3, 73, 8, 1500, 2, 1057, 4294967295, 8, 73, 8, 1502, 1, 4294967295, 4294967295, 1, 73, 8, 1503, 1, 4294967295, 4294967295, 1, 73, 32, 1504, 1, 4294967295, 4294967295, 1, 73, 8, 1505, 1, 4294967295, 4294967295, 3, 73, 8, 1506, 2, 1062, 4294967295, 8, 73, 8, 1508, 1, 4294967295, 4294967295, 1, 73, 8, 1509, 1, 4294967295, 4294967295, 1, 73, 8, 1510, 1, 4294967295, 4294967295, 1, 74, 32, 1511, 1, 4294967295, 4294967295, 1, 74, 8, 1512, 1, 4294967295, 4294967295, 3, 74, 8, 1513, 2, 1068, 4294967295, 8, 74, 8, 1515, 1, 4294967295, 4294967295, 1, 74, 32, 1516, 1, 4294967295, 4294967295, 1, 74, 8, 1517, 1, 4294967295, 4294967295, 1, 75, 8, 1518, 1, 4294967295, 4294967295, 1, 75, 32, 1519, 1, 4294967295, 4294967295, 1, 75, 8, 1520, 1, 4294967295, 4294967295, 5, 75, 8, 1521, 1, 1075, 4294967295, 8, 75, 8, 1522, 1, 4294967295, 4294967295, 10, 75, 8, 1523, 2, 4294967295, 4294967295, 12, 75, 8, 1525, 1, 4294967295, 1078, 9, 75, 8, 1526, 1, 4294967295, 4294967295, 1, 75, 72, 1527, 1, 4294967295, 4294967295, 1, 75, 8, 1528, 1, 4294967295, 4294967295, 1, 76, 8, 1529, 1, 4294967295, 4294967295, 5, 76, 8, 1530, 1, 1083, 4294967295, 8, 76, 8, 1531, 1, 4294967295, 4294967295, 10, 76, 8, 1532, 2, 4294967295, 4294967295, 12, 76, 8, 1534, 1, 4294967295, 1086, 9, 76, 8, 1535, 1, 4294967295, 4294967295, 1, 76, 8, 1536, 1, 4294967295, 4294967295, 1, 76, 8, 1537, 1, 4294967295, 4294967295, 5, 76, 8, 1538, 1, 1090, 4294967295, 8, 76, 8, 1539, 1, 4294967295, 4294967295, 10, 76, 8, 1540, 2, 4294967295, 4294967295, 12, 76, 8, 1542, 1, 4294967295, 1093, 9, 76, 8, 1543, 1, 4294967295, 4294967295, 1, 76, 32, 1544, 1, 4294967295, 4294967295, 3, 76, 8, 1545, 2, 1096, 4294967295, 8, 76, 8, 1547, 1, 4294967295, 4294967295, 1, 76, 8, 1548, 1, 4294967295, 4294967295, 1, 76, 8, 1549, 1, 4294967295, 4294967295, 1, 77, 32, 1550, 1, 4294967295, 4294967295, 1, 77, 8, 1551, 1, 4294967295, 4294967295, 1, 77, 8, 1552, 1, 4294967295, 4294967295, 5, 77, 8, 1553, 2, 1103, 4294967295, 8, 77, 8, 1555, 1, 4294967295, 4294967295, 10, 77, 8, 1556, 2, 4294967295, 4294967295, 12, 77, 8, 1558, 1, 4294967295, 1106, 9, 77, 8, 1559, 1, 4294967295, 4294967295, 1, 77, 32, 1560, 1, 4294967295, 4294967295, 1, 77, 8, 1561, 1, 4294967295, 4294967295, 1, 78, 32, 1562, 1, 4294967295, 4294967295, 1, 78, 8, 1563, 1, 4294967295, 4294967295, 5, 78, 8, 1564, 1, 1112, 4294967295, 8, 78, 8, 1565, 1, 4294967295, 4294967295, 10, 78, 8, 1566, 2, 4294967295, 4294967295, 12, 78, 8, 1568, 1, 4294967295, 1115, 9, 78, 8, 1569, 1, 4294967295, 4294967295, 1, 78, 32, 1570, 1, 4294967295, 4294967295, 1, 78, 8, 1571, 1, 4294967295, 4294967295, 1, 79, 8, 1572, 1, 4294967295, 4294967295, 1, 79, 32, 1573, 1, 4294967295, 4294967295, 1, 79, 8, 1574, 1, 4294967295, 4294967295, 1, 79, 8, 1575, 1, 4294967295, 4294967295, 1, 79, 8, 1576, 1, 4294967295, 4294967295, 3, 79, 8, 1577, 3, 1124, 4294967295, 8, 79, 8, 1580, 1, 4294967295, 4294967295, 1, 80, 8, 1581, 1, 4294967295, 4294967295, 5, 80, 8, 1582, 1, 1127, 4294967295, 8, 80, 8, 1583, 1, 4294967295, 4294967295, 10, 80, 8, 1584, 2, 4294967295, 4294967295, 12, 80, 8, 1586, 1, 4294967295, 1130, 9, 80, 8, 1587, 1, 4294967295, 4294967295, 1, 80, 32, 1588, 1, 4294967295, 4294967295, 1, 80, 8, 1589, 1, 4294967295, 4294967295, 1, 80, 32, 1590, 1, 4294967295, 4294967295, 1, 80, 8, 1591, 1, 4294967295, 4294967295, 1, 80, 8, 1592, 1, 4294967295, 4294967295, 1, 80, 8, 1593, 1, 4294967295, 4294967295, 1, 80, 8, 1594, 1, 4294967295, 4294967295, 1, 80, 8, 1595, 1, 4294967295, 4294967295, 3, 80, 8, 1596, 2, 1140, 4294967295, 8, 80, 8, 1598, 1, 4294967295, 4294967295, 1, 81, 32, 1599, 1, 4294967295, 4294967295, 1, 81, 8, 1600, 1, 4294967295, 4294967295, 1, 82, 32, 1601, 1, 4294967295, 4294967295, 1, 82, 8, 1602, 1, 4294967295, 4294967295, 1, 83, 8, 1603, 1, 4294967295, 4294967295, 5, 83, 8, 1604, 1, 1147, 4294967295, 8, 83, 8, 1605, 1, 4294967295, 4294967295, 10, 83, 8, 1606, 2, 4294967295, 4294967295, 12, 83, 8, 1608, 1, 4294967295, 1150, 9, 83, 8, 1609, 1, 4294967295, 4294967295, 1, 83, 8, 1610, 1, 4294967295, 4294967295, 1, 83, 8, 1611, 1, 4294967295, 4294967295, 1, 83, 8, 1612, 1, 4294967295, 4294967295, 1, 83, 8, 1613, 1, 4294967295, 4294967295, 3, 83, 8, 1614, 4, 1156, 4294967295, 8, 83, 8, 1618, 1, 4294967295, 4294967295, 1, 84, 8, 1619, 1, 4294967295, 4294967295, 1, 84, 32, 1620, 1, 4294967295, 4294967295, 1, 84, 8, 1621, 1, 4294967295, 4294967295, 1, 84, 32, 1622, 1, 4294967295, 4294967295, 1, 84, 8, 1623, 1, 4294967295, 4294967295, 3, 84, 8, 1624, 2, 1163, 4294967295, 8, 84, 8, 1626, 1, 4294967295, 4294967295, 1, 84, 32, 1627, 1, 4294967295, 4294967295, 1, 84, 8, 1628, 1, 4294967295, 4294967295, 1, 84, 32, 1629, 1, 4294967295, 4294967295, 1, 84, 32, 1630, 1, 4294967295, 4294967295, 1, 84, 8, 1631, 1, 4294967295, 4294967295, 1, 84, 32, 1632, 1, 4294967295, 4294967295, 1, 84, 8, 1633, 1, 4294967295, 4294967295, 1, 84, 32, 1634, 1, 4294967295, 4294967295, 1, 84, 8, 1635, 1, 4294967295, 4294967295, 3, 84, 8, 1636, 2, 1174, 4294967295, 8, 84, 8, 1638, 1, 4294967295, 4294967295, 1, 84, 32, 1639, 1, 4294967295, 4294967295, 1, 84, 32, 1640, 1, 4294967295, 4294967295, 1, 84, 8, 1641, 1, 4294967295, 4294967295, 1, 84, 32, 1642, 1, 4294967295, 4294967295, 1, 84, 8, 1643, 1, 4294967295, 4294967295, 1, 84, 8, 1644, 1, 4294967295, 4294967295, 1, 84, 32, 1645, 1, 4294967295, 4294967295, 1, 84, 32, 1646, 1, 4294967295, 4294967295, 1, 84, 8, 1647, 1, 4294967295, 4294967295, 1, 84, 32, 1648, 1, 4294967295, 4294967295, 1, 84, 8, 1649, 1, 4294967295, 4294967295, 1, 84, 8, 1650, 1, 4294967295, 4294967295, 1, 84, 32, 1651, 1, 4294967295, 4294967295, 1, 84, 8, 1652, 1, 4294967295, 4294967295, 1, 84, 32, 1653, 1, 4294967295, 4294967295, 1, 84, 32, 1654, 1, 4294967295, 4294967295, 1, 84, 8, 1655, 1, 4294967295, 4294967295, 1, 84, 32, 1656, 1, 4294967295, 4294967295, 1, 84, 32, 1657, 1, 4294967295, 4294967295, 1, 84, 8, 1658, 1, 4294967295, 4294967295, 1, 84, 32, 1659, 1, 4294967295, 4294967295, 1, 84, 8, 1660, 1, 4294967295, 4294967295, 1, 84, 8, 1661, 1, 4294967295, 4294967295, 4, 84, 8, 1662, 1, 1199, 4294967295, 8, 84, 8, 1663, 1, 4294967295, 4294967295, 11, 84, 8, 1664, 2, 4294967295, 4294967295, 12, 84, 8, 1666, 1, 4294967295, 1200, 1, 84, 8, 1667, 1, 4294967295, 4294967295, 3, 84, 8, 1668, 2, 1204, 4294967295, 8, 84, 8, 1670, 1, 4294967295, 4294967295, 1, 84, 8, 1671, 1, 4294967295, 4294967295, 3, 84, 8, 1672, 2, 1207, 4294967295, 8, 84, 8, 1674, 1, 4294967295, 4294967295, 1, 84, 32, 1675, 1, 4294967295, 4294967295, 1, 84, 8, 1676, 1, 4294967295, 4294967295, 1, 84, 8, 1677, 1, 4294967295, 4294967295, 1, 84, 8, 1678, 1, 4294967295, 4294967295, 5, 84, 8, 1679, 1, 1213, 4294967295, 8, 84, 8, 1680, 1, 4294967295, 4294967295, 10, 84, 8, 1681, 2, 4294967295, 4294967295, 12, 84, 8, 1683, 1, 4294967295, 1216, 9, 84, 8, 1684, 1, 4294967295, 4294967295, 1, 84, 8, 1685, 1, 4294967295, 4294967295, 3, 84, 8, 1686, 2, 1219, 4294967295, 8, 84, 8, 1688, 1, 4294967295, 4294967295, 1, 84, 32, 1689, 1, 4294967295, 4294967295, 1, 84, 32, 1690, 1, 4294967295, 4294967295, 1, 84, 8, 1691, 1, 4294967295, 4294967295, 1, 84, 32, 1692, 1, 4294967295, 4294967295, 1, 84, 32, 1693, 1, 4294967295, 4294967295, 1, 84, 8, 1694, 1, 4294967295, 4294967295, 5, 84, 8, 1695, 1, 1227, 4294967295, 8, 84, 8, 1696, 1, 4294967295, 4294967295, 10, 84, 8, 1697, 2, 4294967295, 4294967295, 12, 84, 8, 1699, 1, 4294967295, 1230, 9, 84, 8, 1700, 1, 4294967295, 4294967295, 1, 84, 8, 1701, 1, 4294967295, 4294967295, 5, 84, 8, 1702, 1, 1233, 4294967295, 8, 84, 8, 1703, 1, 4294967295, 4294967295, 10, 84, 8, 1704, 2, 4294967295, 4294967295, 12, 84, 8, 1706, 1, 4294967295, 1236, 9, 84, 8, 1707, 1, 4294967295, 4294967295, 1, 84, 32, 1708, 1, 4294967295, 4294967295, 1, 84, 8, 1709, 1, 4294967295, 4294967295, 1, 84, 32, 1710, 1, 4294967295, 4294967295, 1, 84, 32, 1711, 1, 4294967295, 4294967295, 1, 84, 8, 1712, 1, 4294967295, 4294967295, 1, 84, 32, 1713, 1, 4294967295, 4294967295, 1, 84, 8, 1714, 1, 4294967295, 4294967295, 1, 84, 8, 1715, 1, 4294967295, 4294967295, 1, 84, 32, 1716, 1, 4294967295, 4294967295, 1, 84, 8, 1717, 1, 4294967295, 4294967295, 3, 84, 8, 1718, 2, 1248, 4294967295, 8, 84, 8, 1720, 1, 4294967295, 4294967295, 1, 84, 32, 1721, 1, 4294967295, 4294967295, 1, 84, 32, 1722, 1, 4294967295, 4294967295, 1, 84, 8, 1723, 1, 4294967295, 4294967295, 1, 84, 32, 1724, 1, 4294967295, 4294967295, 1, 84, 8, 1725, 1, 4294967295, 4294967295, 1, 84, 32, 1726, 1, 4294967295, 4294967295, 1, 84, 8, 1727, 1, 4294967295, 4294967295, 3, 84, 8, 1728, 2, 1257, 4294967295, 8, 84, 8, 1730, 1, 4294967295, 4294967295, 1, 84, 32, 1731, 1, 4294967295, 4294967295, 1, 84, 32, 1732, 1, 4294967295, 4294967295, 1, 84, 8, 1733, 1, 4294967295, 4294967295, 3, 84, 8, 1734, 2, 1262, 4294967295, 8, 84, 8, 1736, 1, 4294967295, 4294967295, 1, 84, 32, 1737, 1, 4294967295, 4294967295, 1, 84, 32, 1738, 1, 4294967295, 4294967295, 1, 84, 8, 1739, 1, 4294967295, 4294967295, 1, 84, 32, 1740, 1, 4294967295, 4294967295, 1, 84, 8, 1741, 1, 4294967295, 4294967295, 1, 84, 32, 1742, 1, 4294967295, 4294967295, 1, 84, 8, 1743, 1, 4294967295, 4294967295, 1, 84, 32, 1744, 1, 4294967295, 4294967295, 1, 84, 8, 1745, 1, 4294967295, 4294967295, 1, 84, 8, 1746, 1, 4294967295, 4294967295, 1, 84, 32, 1747, 1, 4294967295, 4294967295, 3, 84, 8, 1748, 2, 1275, 4294967295, 8, 84, 8, 1750, 1, 4294967295, 4294967295, 1, 84, 8, 1751, 1, 4294967295, 4294967295, 1, 84, 32, 1752, 1, 4294967295, 4294967295, 1, 84, 8, 1753, 1, 4294967295, 4294967295, 1, 84, 8, 1754, 1, 4294967295, 4294967295, 3, 84, 8, 1755, 19, 1281, 4294967295, 8, 84, 8, 1774, 1, 4294967295, 4294967295, 1, 85, 32, 1775, 1, 4294967295, 4294967295, 1, 85, 32, 1776, 1, 4294967295, 4294967295, 1, 85, 8, 1777, 1, 4294967295, 4294967295, 5, 85, 8, 1778, 1, 1286, 4294967295, 8, 85, 8, 1779, 1, 4294967295, 4294967295, 10, 85, 8, 1780, 2, 4294967295, 4294967295, 12, 85, 8, 1782, 1, 4294967295, 1289, 9, 85, 8, 1783, 1, 4294967295, 4294967295, 1, 85, 8, 1784, 1, 4294967295, 4294967295, 1, 85, 8, 1785, 1, 4294967295, 4294967295, 1, 85, 32, 1786, 1, 4294967295, 4294967295, 1, 85, 8, 1787, 1, 4294967295, 4294967295, 1, 85, 8, 1788, 1, 4294967295, 4294967295, 1, 86, 8, 1789, 1, 4294967295, 4294967295, 1, 86, 32, 1790, 1, 4294967295, 4294967295, 1, 86, 8, 1791, 1, 4294967295, 4294967295, 5, 86, 8, 1792, 1, 1299, 4294967295, 8, 86, 8, 1793, 1, 4294967295, 4294967295, 10, 86, 8, 1794, 2, 4294967295, 4294967295, 12, 86, 8, 1796, 1, 4294967295, 1302, 9, 86, 8, 1797, 1, 4294967295, 4294967295, 1, 87, 32, 1798, 1, 4294967295, 4294967295, 1, 87, 8, 1799, 1, 4294967295, 4294967295, 1, 87, 8, 1800, 1, 4294967295, 4294967295, 1, 88, 32, 1801, 1, 4294967295, 4294967295, 1, 88, 8, 1802, 1, 4294967295, 4294967295, 1, 88, 32, 1803, 1, 4294967295, 4294967295, 3, 88, 8, 1804, 2, 1310, 4294967295, 8, 88, 8, 1806, 1, 4294967295, 4294967295, 1, 88, 32, 1807, 1, 4294967295, 4294967295, 1, 88, 8, 1808, 1, 4294967295, 4294967295, 1, 89, 8, 1809, 1, 4294967295, 4294967295, 1, 89, 32, 1810, 1, 4294967295, 4294967295, 1, 89, 8, 1811, 1, 4294967295, 4294967295, 5, 89, 8, 1812, 1, 1317, 4294967295, 8, 89, 8, 1813, 1, 4294967295, 4294967295, 10, 89, 8, 1814, 2, 4294967295, 4294967295, 12, 89, 8, 1816, 1, 4294967295, 1320, 9, 89, 8, 1817, 1, 4294967295, 4294967295, 1, 90, 8, 1818, 1, 4294967295, 4294967295, 5, 90, 8, 1819, 1, 1323, 4294967295, 8, 90, 8, 1820, 1, 4294967295, 4294967295, 10, 90, 8, 1821, 2, 4294967295, 4294967295, 12, 90, 8, 1823, 1, 4294967295, 1326, 9, 90, 8, 1824, 1, 4294967295, 4294967295, 1, 90, 8, 1825, 1, 4294967295, 4294967295, 1, 90, 8, 1826, 1, 4294967295, 4294967295, 1, 90, 8, 1827, 1, 4294967295, 4294967295, 1, 90, 32, 1828, 1, 4294967295, 4294967295, 1, 90, 8, 1829, 1, 4294967295, 4294967295, 3, 90, 8, 1830, 2, 1333, 4294967295, 8, 90, 8, 1832, 1, 4294967295, 4294967295, 1, 90, 32, 1833, 1, 4294967295, 4294967295, 1, 90, 8, 1834, 1, 4294967295, 4294967295, 1, 90, 8, 1835, 1, 4294967295, 4294967295, 1, 90, 8, 1836, 1, 4294967295, 4294967295, 3, 90, 8, 1837, 2, 1339, 4294967295, 8, 90, 8, 1839, 1, 4294967295, 4294967295, 1, 91, 8, 1840, 1, 4294967295, 4294967295, 1, 91, 32, 1841, 1, 4294967295, 4294967295, 1, 91, 8, 1842, 1, 4294967295, 4294967295, 4, 91, 8, 1843, 1, 1344, 4294967295, 8, 91, 8, 1844, 1, 4294967295, 4294967295, 11, 91, 8, 1845, 2, 4294967295, 4294967295, 12, 91, 8, 1847, 1, 4294967295, 1345, 1, 91, 8, 1848, 1, 4294967295, 4294967295, 4, 91, 8, 1849, 1, 1349, 4294967295, 8, 91, 8, 1850, 1, 4294967295, 4294967295, 11, 91, 8, 1851, 2, 4294967295, 4294967295, 12, 91, 8, 1853, 1, 4294967295, 1350, 1, 92, 32, 1854, 1, 4294967295, 4294967295, 1, 92, 8, 1855, 1, 4294967295, 4294967295, 1, 92, 32, 1856, 1, 4294967295, 4294967295, 1, 92, 8, 1857, 1, 4294967295, 4294967295, 1, 92, 8, 1858, 1, 4294967295, 4294967295, 1, 92, 8, 1859, 1, 4294967295, 4294967295, 3, 92, 8, 1860, 3, 1359, 4294967295, 8, 92, 8, 1863, 1, 4294967295, 4294967295, 1, 92, 32, 1864, 1, 4294967295, 4294967295, 3, 92, 8, 1865, 2, 1362, 4294967295, 8, 92, 8, 1867, 1, 4294967295, 4294967295, 1, 93, 8, 1868, 1, 4294967295, 4294967295, 1, 93, 8, 1869, 1, 4294967295, 4294967295, 3, 93, 8, 1870, 2, 1366, 4294967295, 8, 93, 8, 1872, 1, 4294967295, 4294967295, 1, 93, 32, 1873, 1, 4294967295, 4294967295, 1, 93, 8, 1874, 1, 4294967295, 4294967295, 3, 93, 8, 1875, 2, 1370, 4294967295, 8, 93, 8, 1877, 1, 4294967295, 4294967295, 1, 93, 32, 1878, 1, 4294967295, 4294967295, 1, 93, 8, 1879, 1, 4294967295, 4294967295, 3, 93, 8, 1880, 2, 1374, 4294967295, 8, 93, 8, 1882, 1, 4294967295, 4294967295, 3, 93, 8, 1883, 2, 1376, 4294967295, 8, 93, 8, 1885, 1, 4294967295, 4294967295, 1, 94, 8, 1886, 1, 4294967295, 4294967295, 1, 94, 8, 1887, 1, 4294967295, 4294967295, 3, 94, 8, 1888, 2, 1380, 4294967295, 8, 94, 8, 1890, 1, 4294967295, 4294967295, 1, 95, 8, 1891, 1, 4294967295, 4294967295, 5, 95, 8, 1892, 1, 1383, 4294967295, 8, 95, 8, 1893, 1, 4294967295, 4294967295, 10, 95, 8, 1894, 2, 4294967295, 4294967295, 12, 95, 8, 1896, 1, 4294967295, 1386, 9, 95, 8, 1897, 1, 4294967295, 4294967295, 1, 95, 8, 1898, 1, 4294967295, 4294967295, 1, 95, 32, 1899, 1, 4294967295, 4294967295, 3, 95, 8, 1900, 2, 1390, 4294967295, 8, 95, 8, 1902, 1, 4294967295, 4294967295, 1, 95, 8, 1903, 1, 4294967295, 4294967295, 1, 95, 32, 1904, 1, 4294967295, 4294967295, 1, 95, 8, 1905, 1, 4294967295, 4294967295, 1, 95, 8, 1906, 1, 4294967295, 4294967295, 1, 96, 8, 1907, 1, 4294967295, 4294967295, 1, 96, 32, 1908, 1, 4294967295, 4294967295, 1, 96, 8, 1909, 1, 4294967295, 4294967295, 5, 96, 8, 1910, 1, 1399, 4294967295, 8, 96, 8, 1911, 1, 4294967295, 4294967295, 10, 96, 8, 1912, 2, 4294967295, 4294967295, 12, 96, 8, 1914, 1, 4294967295, 1402, 9, 96, 8, 1915, 1, 4294967295, 4294967295, 1, 97, 8, 1916, 1, 4294967295, 4294967295, 1, 97, 32, 1917, 1, 4294967295, 4294967295, 1, 97, 32, 1918, 1, 4294967295, 4294967295, 3, 97, 8, 1919, 3, 1407, 4294967295, 8, 97, 8, 1922, 1, 4294967295, 4294967295, 1, 97, 8, 1923, 1, 4294967295, 4294967295, 1, 97, 8, 1924, 1, 4294967295, 4294967295, 1, 98, 72, 1925, 1, 4294967295, 4294967295, 1, 98, 8, 1926, 1, 4294967295, 4294967295, 1, 98, 8, 1927, 1, 4294967295, 4294967295, 1, 98, 8, 1928, 1, 4294967295, 4294967295, 1, 98, 32, 1929, 1, 4294967295, 4294967295, 1, 98, 8, 1930, 1, 4294967295, 4294967295, 3, 98, 8, 1931, 2, 1417, 4294967295, 8, 98, 8, 1933, 1, 4294967295, 4294967295, 1, 98, 8, 1934, 1, 4294967295, 4294967295, 1, 98, 32, 1935, 1, 4294967295, 4294967295, 3, 98, 8, 1936, 2, 1421, 4294967295, 8, 98, 8, 1938, 1, 4294967295, 4294967295, 1, 98, 8, 1939, 1, 4294967295, 4294967295, 1, 98, 32, 1940, 1, 4294967295, 4294967295, 1, 98, 8, 1941, 1, 4294967295, 4294967295, 3, 98, 8, 1942, 2, 1426, 4294967295, 8, 98, 8, 1944, 1, 4294967295, 4294967295, 1, 98, 32, 1945, 1, 4294967295, 4294967295, 1, 98, 8, 1946, 1, 4294967295, 4294967295, 1, 98, 8, 1947, 1, 4294967295, 4294967295, 1, 98, 32, 1948, 1, 4294967295, 4294967295, 1, 98, 8, 1949, 1, 4294967295, 4294967295, 1, 98, 32, 1950, 1, 4294967295, 4294967295, 1, 98, 8, 1951, 1, 4294967295, 4294967295, 5, 98, 8, 1952, 1, 1435, 4294967295, 8, 98, 8, 1953, 1, 4294967295, 4294967295, 10, 98, 8, 1954, 2, 4294967295, 4294967295, 12, 98, 8, 1956, 1, 4294967295, 1438, 9, 98, 8, 1957, 1, 4294967295, 4294967295, 1, 98, 8, 1958, 1, 4294967295, 4294967295, 1, 98, 32, 1959, 1, 4294967295, 4294967295, 1, 98, 8, 1960, 1, 4294967295, 4294967295, 5, 98, 8, 1961, 1, 1443, 4294967295, 8, 98, 8, 1962, 1, 4294967295, 4294967295, 10, 98, 8, 1963, 2, 4294967295, 4294967295, 12, 98, 8, 1965, 1, 4294967295, 1446, 9, 98, 8, 1966, 1, 4294967295, 4294967295, 1, 98, 32, 1967, 1, 4294967295, 4294967295, 1, 98, 8, 1968, 1, 4294967295, 4294967295, 1, 98, 8, 1969, 1, 4294967295, 4294967295, 1, 98, 32, 1970, 1, 4294967295, 4294967295, 1, 98, 8, 1971, 1, 4294967295, 4294967295, 1, 98, 8, 1972, 1, 4294967295, 4294967295, 3, 98, 8, 1973, 9, 1454, 4294967295, 8, 98, 8, 1982, 1, 4294967295, 4294967295, 1, 98, 72, 1983, 1, 4294967295, 4294967295, 1, 98, 32, 1984, 1, 4294967295, 4294967295, 1, 98, 8, 1985, 1, 4294967295, 4294967295, 1, 98, 32, 1986, 1, 4294967295, 4294967295, 1, 98, 8, 1987, 1, 4294967295, 4294967295, 1, 98, 72, 1988, 1, 4294967295, 4294967295, 1, 98, 32, 1989, 1, 4294967295, 4294967295, 1, 98, 8, 1990, 1, 4294967295, 4294967295, 1, 98, 8, 1991, 1, 4294967295, 4294967295, 1, 98, 32, 1992, 1, 4294967295, 4294967295, 1, 98, 32, 1993, 1, 4294967295, 4294967295, 1, 98, 8, 1994, 1, 4294967295, 4294967295, 3, 98, 8, 1995, 2, 1468, 4294967295, 8, 98, 8, 1997, 1, 4294967295, 4294967295, 1, 98, 8, 1998, 1, 4294967295, 4294967295, 1, 98, 32, 1999, 1, 4294967295, 4294967295, 1, 98, 8, 2000, 1, 4294967295, 4294967295, 1, 98, 8, 2001, 1, 4294967295, 4294967295, 3, 98, 8, 2002, 6, 1474, 4294967295, 8, 98, 8, 2008, 1, 4294967295, 4294967295, 1, 98, 72, 2009, 1, 4294967295, 4294967295, 1, 98, 32, 2010, 1, 4294967295, 4294967295, 1, 98, 8, 2011, 1, 4294967295, 4294967295, 3, 98, 8, 2012, 2, 1479, 4294967295, 8, 98, 8, 2014, 1, 4294967295, 4294967295, 1, 98, 8, 2015, 1, 4294967295, 4294967295, 1, 98, 72, 2016, 1, 4294967295, 4294967295, 1, 98, 32, 2017, 1, 4294967295, 4294967295, 1, 98, 72, 2018, 1, 4294967295, 4294967295, 1, 98, 32, 2019, 1, 4294967295, 4294967295, 1, 98, 8, 2020, 1, 4294967295, 4294967295, 1, 98, 72, 2021, 1, 4294967295, 4294967295, 1, 98, 32, 2022, 1, 4294967295, 4294967295, 1, 98, 8, 2023, 1, 4294967295, 4294967295, 1, 98, 72, 2024, 1, 4294967295, 4294967295, 1, 98, 32, 2025, 1, 4294967295, 4294967295, 1, 98, 32, 2026, 1, 4294967295, 4294967295, 1, 98, 32, 2027, 1, 4294967295, 4294967295, 1, 98, 32, 2028, 1, 4294967295, 4294967295, 1, 98, 32, 2029, 1, 4294967295, 4294967295, 1, 98, 32, 2030, 1, 4294967295, 4294967295, 1, 98, 32, 2031, 1, 4294967295, 4294967295, 3, 98, 8, 2032, 3, 1498, 4294967295, 8, 98, 8, 2035, 1, 4294967295, 4294967295, 1, 98, 8, 2036, 1, 4294967295, 4294967295, 1, 98, 72, 2037, 1, 4294967295, 4294967295, 1, 98, 32, 2038, 1, 4294967295, 4294967295, 1, 98, 8, 2039, 1, 4294967295, 4294967295, 1, 98, 72, 2040, 1, 4294967295, 4294967295, 1, 98, 32, 2041, 1, 4294967295, 4294967295, 1, 98, 8, 2042, 1, 4294967295, 4294967295, 1, 98, 8, 2043, 1, 4294967295, 4294967295, 3, 98, 8, 2044, 2, 1508, 4294967295, 8, 98, 8, 2046, 1, 4294967295, 4294967295, 1, 98, 72, 2047, 1, 4294967295, 4294967295, 1, 98, 32, 2048, 1, 4294967295, 4294967295, 1, 98, 8, 2049, 1, 4294967295, 4294967295, 1, 98, 72, 2050, 1, 4294967295, 4294967295, 1, 98, 32, 2051, 1, 4294967295, 4294967295, 1, 98, 8, 2052, 1, 4294967295, 4294967295, 1, 98, 72, 2053, 1, 4294967295, 4294967295, 1, 98, 32, 2054, 1, 4294967295, 4294967295, 1, 98, 8, 2055, 1, 4294967295, 4294967295, 1, 98, 72, 2056, 1, 4294967295, 4294967295, 1, 98, 32, 2057, 1, 4294967295, 4294967295, 1, 98, 8, 2058, 1, 4294967295, 4294967295, 1, 98, 72, 2059, 1, 4294967295, 4294967295, 1, 98, 32, 2060, 1, 4294967295, 4294967295, 1, 98, 8, 2061, 1, 4294967295, 4294967295, 1, 98, 72, 2062, 1, 4294967295, 4294967295, 1, 98, 32, 2063, 1, 4294967295, 4294967295, 1, 98, 8, 2064, 1, 4294967295, 4294967295, 1, 98, 72, 2065, 1, 4294967295, 4294967295, 1, 98, 32, 2066, 1, 4294967295, 4294967295, 1, 98, 8, 2067, 1, 4294967295, 4294967295, 1, 98, 32, 2068, 1, 4294967295, 4294967295, 1, 98, 8, 2069, 1, 4294967295, 4294967295, 1, 98, 8, 2070, 1, 4294967295, 4294967295, 1, 98, 72, 2071, 1, 4294967295, 4294967295, 1, 98, 32, 2072, 1, 4294967295, 4294967295, 1, 98, 8, 2073, 1, 4294967295, 4294967295, 5, 98, 8, 2074, 17, 1537, 4294967295, 8, 98, 8, 2091, 1, 4294967295, 4294967295, 10, 98, 10, 2092, 2, 4294967295, 4294967295, 12, 98, 8, 2094, 1, 4294967295, 1540, 9, 98, 8, 2095, 1, 4294967295, 4294967295, 1, 99, 8, 2096, 1, 4294967295, 4294967295, 5, 99, 8, 2097, 1, 1543, 4294967295, 8, 99, 8, 2098, 1, 4294967295, 4294967295, 10, 99, 8, 2099, 2, 4294967295, 4294967295, 12, 99, 8, 2101, 1, 4294967295, 1546, 9, 99, 8, 2102, 1, 4294967295, 4294967295, 1, 99, 8, 2103, 1, 4294967295, 4294967295, 1, 99, 8, 2104, 1, 4294967295, 4294967295, 5, 99, 8, 2105, 1, 1550, 4294967295, 8, 99, 8, 2106, 1, 4294967295, 4294967295, 10, 99, 8, 2107, 2, 4294967295, 4294967295, 12, 99, 8, 2109, 1, 4294967295, 1553, 9, 99, 8, 2110, 1, 4294967295, 4294967295, 1, 99, 8, 2111, 1, 4294967295, 4294967295, 1, 99, 8, 2112, 1, 4294967295, 4294967295, 1, 99, 8, 2113, 1, 4294967295, 4294967295, 1, 99, 32, 2114, 1, 4294967295, 4294967295, 1, 99, 8, 2115, 1, 4294967295, 4294967295, 3, 99, 8, 2116, 2, 1560, 4294967295, 8, 99, 8, 2118, 1, 4294967295, 4294967295, 1, 99, 32, 2119, 1, 4294967295, 4294967295, 1, 99, 8, 2120, 1, 4294967295, 4294967295, 3, 99, 8, 2121, 2, 1564, 4294967295, 8, 99, 8, 2123, 1, 4294967295, 4294967295, 1, 100, 8, 2124, 1, 4294967295, 4294967295, 1, 100, 32, 2125, 1, 4294967295, 4294967295, 1, 100, 8, 2126, 1, 4294967295, 4294967295, 5, 100, 8, 2127, 1, 1569, 4294967295, 8, 100, 8, 2128, 1, 4294967295, 4294967295, 10, 100, 8, 2129, 2, 4294967295, 4294967295, 12, 100, 8, 2131, 1, 4294967295, 1572, 9, 100, 8, 2132, 1, 4294967295, 4294967295, 1, 101, 8, 2133, 1, 4294967295, 4294967295, 1, 101, 8, 2134, 1, 4294967295, 4294967295, 1, 102, 8, 2135, 1, 4294967295, 4294967295, 1, 102, 32, 2136, 1, 4294967295, 4294967295, 1, 102, 8, 2137, 1, 4294967295, 4294967295, 1, 102, 8, 2138, 1, 4294967295, 4294967295, 1, 103, 8, 2139, 1, 4294967295, 4294967295, 1, 103, 32, 2140, 1, 4294967295, 4294967295, 1, 103, 8, 2141, 1, 4294967295, 4294967295, 3, 103, 8, 2142, 2, 1583, 4294967295, 8, 103, 8, 2144, 1, 4294967295, 4294967295, 1, 103, 32, 2145, 1, 4294967295, 4294967295, 1, 103, 32, 2146, 1, 4294967295, 4294967295, 1, 103, 8, 2147, 1, 4294967295, 4294967295, 1, 103, 32, 2148, 1, 4294967295, 4294967295, 1, 103, 8, 2149, 1, 4294967295, 4294967295, 5, 103, 8, 2150, 1, 1590, 4294967295, 8, 103, 8, 2151, 1, 4294967295, 4294967295, 10, 103, 8, 2152, 2, 4294967295, 4294967295, 12, 103, 8, 2154, 1, 4294967295, 1593, 9, 103, 8, 2155, 1, 4294967295, 4294967295, 1, 103, 32, 2156, 1, 4294967295, 4294967295, 1, 103, 8, 2157, 1, 4294967295, 4294967295, 1, 103, 32, 2158, 1, 4294967295, 4294967295, 1, 103, 8, 2159, 1, 4294967295, 4294967295, 3, 103, 8, 2160, 2, 1599, 4294967295, 8, 103, 8, 2162, 1, 4294967295, 4294967295, 1, 103, 32, 2163, 1, 4294967295, 4294967295, 3, 103, 8, 2164, 4, 1602, 4294967295, 8, 103, 8, 2168, 1, 4294967295, 4294967295, 1, 104, 8, 2169, 1, 4294967295, 4294967295, 1, 104, 8, 2170, 1, 4294967295, 4294967295, 3, 104, 8, 2171, 2, 1606, 4294967295, 8, 104, 8, 2173, 1, 4294967295, 4294967295, 1, 105, 32, 2174, 1, 4294967295, 4294967295, 1, 105, 8, 2175, 1, 4294967295, 4294967295, 1, 105, 32, 2176, 1, 4294967295, 4294967295, 1, 105, 8, 2177, 1, 4294967295, 4294967295, 1, 105, 32, 2178, 1, 4294967295, 4294967295, 1, 105, 32, 2179, 1, 4294967295, 4294967295, 1, 105, 8, 2180, 1, 4294967295, 4294967295, 1, 105, 8, 2181, 1, 4294967295, 4294967295, 1, 105, 8, 2182, 1, 4294967295, 4294967295, 1, 105, 32, 2183, 1, 4294967295, 4294967295, 1, 105, 32, 2184, 1, 4294967295, 4294967295, 1, 105, 8, 2185, 1, 4294967295, 4294967295, 1, 105, 8, 2186, 1, 4294967295, 4294967295, 1, 105, 8, 2187, 1, 4294967295, 4294967295, 1, 105, 32, 2188, 1, 4294967295, 4294967295, 1, 105, 8, 2189, 1, 4294967295, 4294967295, 3, 105, 8, 2190, 2, 1624, 4294967295, 8, 105, 8, 2192, 1, 4294967295, 4294967295, 3, 105, 8, 2193, 7, 1626, 4294967295, 8, 105, 8, 2200, 1, 4294967295, 4294967295, 1, 106, 32, 2201, 1, 4294967295, 4294967295, 1, 106, 32, 2202, 1, 4294967295, 4294967295, 1, 106, 8, 2203, 1, 4294967295, 4294967295, 1, 106, 32, 2204, 1, 4294967295, 4294967295, 1, 106, 32, 2205, 1, 4294967295, 4294967295, 1, 106, 8, 2206, 1, 4294967295, 4294967295, 5, 106, 8, 2207, 1, 1634, 4294967295, 8, 106, 8, 2208, 1, 4294967295, 4294967295, 10, 106, 8, 2209, 2, 4294967295, 4294967295, 12, 106, 8, 2211, 1, 4294967295, 1637, 9, 106, 8, 2212, 1, 4294967295, 4294967295, 1, 106, 32, 2213, 1, 4294967295, 4294967295, 1, 106, 8, 2214, 1, 4294967295, 4294967295, 1, 107, 32, 2215, 1, 4294967295, 4294967295, 1, 107, 8, 2216, 1, 4294967295, 4294967295, 1, 107, 32, 2217, 1, 4294967295, 4294967295, 1, 107, 32, 2218, 1, 4294967295, 4294967295, 1, 107, 32, 2219, 1, 4294967295, 4294967295, 3, 107, 8, 2220, 2, 1646, 4294967295, 8, 107, 8, 2222, 1, 4294967295, 4294967295, 1, 107, 8, 2223, 1, 4294967295, 4294967295, 1, 107, 32, 2224, 1, 4294967295, 4294967295, 1, 107, 8, 2225, 1, 4294967295, 4294967295, 5, 107, 8, 2226, 1, 1651, 4294967295, 8, 107, 8, 2227, 1, 4294967295, 4294967295, 10, 107, 8, 2228, 2, 4294967295, 4294967295, 12, 107, 8, 2230, 1, 4294967295, 1654, 9, 107, 8, 2231, 1, 4294967295, 4294967295, 1, 107, 8, 2232, 1, 4294967295, 4294967295, 3, 107, 8, 2233, 2, 1657, 4294967295, 8, 107, 8, 2235, 1, 4294967295, 4294967295, 3, 107, 8, 2236, 3, 1659, 4294967295, 8, 107, 8, 2239, 1, 4294967295, 4294967295, 1, 107, 32, 2240, 1, 4294967295, 4294967295, 1, 107, 8, 2241, 1, 4294967295, 4294967295, 1, 107, 32, 2242, 1, 4294967295, 4294967295, 1, 107, 32, 2243, 1, 4294967295, 4294967295, 1, 107, 8, 2244, 1, 4294967295, 4294967295, 3, 107, 8, 2245, 2, 1666, 4294967295, 8, 107, 8, 2247, 1, 4294967295, 4294967295, 1, 108, 32, 2248, 1, 4294967295, 4294967295, 1, 108, 8, 2249, 1, 4294967295, 4294967295, 1, 108, 8, 2250, 1, 4294967295, 4294967295, 1, 109, 8, 2251, 1, 4294967295, 4294967295, 1, 109, 8, 2252, 1, 4294967295, 4294967295, 1, 110, 8, 2253, 1, 4294967295, 4294967295, 1, 110, 8, 2254, 1, 4294967295, 4294967295, 5, 110, 8, 2255, 1, 1675, 4294967295, 8, 110, 8, 2256, 1, 4294967295, 4294967295, 10, 110, 8, 2257, 2, 4294967295, 4294967295, 12, 110, 8, 2259, 1, 4294967295, 1678, 9, 110, 8, 2260, 1, 4294967295, 4294967295, 3, 110, 8, 2261, 2, 1680, 4294967295, 8, 110, 8, 2263, 1, 4294967295, 4294967295, 1, 111, 8, 2264, 1, 4294967295, 4294967295, 1, 111, 8, 2265, 1, 4294967295, 4294967295, 1, 112, 8, 2266, 1, 4294967295, 4294967295, 3, 112, 8, 2267, 2, 1685, 4294967295, 8, 112, 8, 2269, 1, 4294967295, 4294967295, 1, 112, 8, 2270, 1, 4294967295, 4294967295, 1, 112, 8, 2271, 1, 4294967295, 4294967295, 1, 112, 8, 2272, 1, 4294967295, 4294967295, 1, 112, 8, 2273, 1, 4294967295, 4294967295, 1, 112, 8, 2274, 1, 4294967295, 4294967295, 1, 112, 8, 2275, 1, 4294967295, 4294967295, 3, 112, 8, 2276, 2, 1693, 4294967295, 8, 112, 8, 2278, 1, 4294967295, 4294967295, 1, 113, 8, 2279, 1, 4294967295, 4294967295, 1, 113, 8, 2280, 1, 4294967295, 4294967295, 3, 113, 8, 2281, 2, 1697, 4294967295, 8, 113, 8, 2283, 1, 4294967295, 4294967295, 1, 113, 32, 2284, 1, 4294967295, 4294967295, 1, 113, 8, 2285, 1, 4294967295, 4294967295, 1, 113, 8, 2286, 1, 4294967295, 4294967295, 3, 113, 8, 2287, 2, 1702, 4294967295, 8, 113, 8, 2289, 1, 4294967295, 4294967295, 5, 113, 8, 2290, 1, 1704, 4294967295, 8, 113, 8, 2291, 1, 4294967295, 4294967295, 10, 113, 8, 2292, 2, 4294967295, 4294967295, 12, 113, 8, 2294, 1, 4294967295, 1707, 9, 113, 8, 2295, 1, 4294967295, 4294967295, 1, 113, 8, 2296, 1, 4294967295, 4294967295, 3, 113, 8, 2297, 2, 1710, 4294967295, 8, 113, 8, 2299, 1, 4294967295, 4294967295, 1, 114, 8, 2300, 1, 4294967295, 4294967295, 1, 114, 8, 2301, 1, 4294967295, 4294967295, 3, 114, 8, 2302, 2, 1714, 4294967295, 8, 114, 8, 2304, 1, 4294967295, 4294967295, 1, 114, 8, 2305, 1, 4294967295, 4294967295, 1, 114, 8, 2306, 1, 4294967295, 4294967295, 1, 115, 32, 2307, 1, 4294967295, 4294967295, 1, 115, 32, 2308, 1, 4294967295, 4294967295, 4, 115, 8, 2309, 1, 1720, 4294967295, 8, 115, 8, 2310, 1, 4294967295, 4294967295, 11, 115, 8, 2311, 2, 4294967295, 4294967295, 12, 115, 8, 2313, 1, 4294967295, 1721, 1, 115, 8, 2314, 1, 4294967295, 4294967295, 1, 115, 32, 2315, 1, 4294967295, 4294967295, 1, 115, 8, 2316, 1, 4294967295, 4294967295, 1, 115, 32, 2317, 1, 4294967295, 4294967295, 1, 115, 8, 2318, 1, 4294967295, 4294967295, 4, 115, 8, 2319, 1, 1729, 4294967295, 8, 115, 8, 2320, 1, 4294967295, 4294967295, 11, 115, 8, 2321, 2, 4294967295, 4294967295, 12, 115, 8, 2323, 1, 4294967295, 1730, 1, 115, 32, 2324, 1, 4294967295, 4294967295, 1, 115, 32, 2325, 1, 4294967295, 4294967295, 5, 115, 8, 2326, 1, 1735, 4294967295, 8, 115, 8, 2327, 1, 4294967295, 4294967295, 10, 115, 8, 2328, 2, 4294967295, 4294967295, 12, 115, 8, 2330, 1, 4294967295, 1738, 9, 115, 8, 2331, 1, 4294967295, 4294967295, 3, 115, 8, 2332, 2, 1740, 4294967295, 8, 115, 8, 2334, 1, 4294967295, 4294967295, 1, 116, 8, 2335, 1, 4294967295, 4294967295, 1, 116, 8, 2336, 1, 4294967295, 4294967295, 3, 116, 8, 2337, 2, 1744, 4294967295, 8, 116, 8, 2339, 1, 4294967295, 4294967295, 1, 117, 8, 2340, 1, 4294967295, 4294967295, 1, 117, 8, 2341, 1, 4294967295, 4294967295, 1, 117, 8, 2342, 1, 4294967295, 4294967295, 1, 118, 32, 2343, 1, 4294967295, 4294967295, 1, 118, 32, 2344, 1, 4294967295, 4294967295, 1, 118, 8, 2345, 1, 4294967295, 4294967295, 3, 118, 8, 2346, 2, 1752, 4294967295, 8, 118, 8, 2348, 1, 4294967295, 4294967295, 1, 119, 32, 2349, 1, 4294967295, 4294967295, 1, 119, 32, 2350, 1, 4294967295, 4294967295, 1, 119, 8, 2351, 1, 4294967295, 4294967295, 3, 119, 8, 2352, 2, 1757, 4294967295, 8, 119, 8, 2354, 1, 4294967295, 4294967295, 1, 120, 32, 2355, 1, 4294967295, 4294967295, 1, 120, 8, 2356, 1, 4294967295, 4294967295, 1, 120, 32, 2357, 1, 4294967295, 4294967295, 1, 120, 8, 2358, 1, 4294967295, 4294967295, 1, 121, 8, 2359, 1, 4294967295, 4294967295, 1, 121, 32, 2360, 1, 4294967295, 4294967295, 1, 121, 8, 2361, 1, 4294967295, 4294967295, 5, 121, 8, 2362, 1, 1766, 4294967295, 8, 121, 8, 2363, 1, 4294967295, 4294967295, 10, 121, 8, 2364, 2, 4294967295, 4294967295, 12, 121, 8, 2366, 1, 4294967295, 1769, 9, 121, 8, 2367, 1, 4294967295, 4294967295, 1, 122, 8, 2368, 1, 4294967295, 4294967295, 5, 122, 8, 2369, 1, 1772, 4294967295, 8, 122, 8, 2370, 1, 4294967295, 4294967295, 10, 122, 8, 2371, 2, 4294967295, 4294967295, 12, 122, 8, 2373, 1, 4294967295, 1775, 9, 122, 8, 2374, 1, 4294967295, 4294967295, 1, 122, 8, 2375, 1, 4294967295, 4294967295, 1, 122, 8, 2376, 1, 4294967295, 4294967295, 3, 122, 8, 2377, 2, 1779, 4294967295, 8, 122, 8, 2379, 1, 4294967295, 4294967295, 1, 122, 8, 2380, 1, 4294967295, 4294967295, 5, 122, 8, 2381, 1, 1782, 4294967295, 8, 122, 8, 2382, 1, 4294967295, 4294967295, 10, 122, 8, 2383, 2, 4294967295, 4294967295, 12, 122, 8, 2385, 1, 4294967295, 1785, 9, 122, 8, 2386, 1, 4294967295, 4294967295, 1, 122, 32, 2387, 1, 4294967295, 4294967295, 1, 122, 32, 2388, 1, 4294967295, 4294967295, 5, 122, 8, 2389, 1, 1789, 4294967295, 8, 122, 8, 2390, 1, 4294967295, 4294967295, 10, 122, 8, 2391, 2, 4294967295, 4294967295, 12, 122, 8, 2393, 1, 4294967295, 1792, 9, 122, 8, 2394, 1, 4294967295, 4294967295, 1, 123, 32, 2395, 1, 4294967295, 4294967295, 1, 123, 8, 2396, 1, 4294967295, 4294967295, 1, 124, 32, 2397, 1, 4294967295, 4294967295, 1, 124, 8, 2398, 1, 4294967295, 4294967295, 1, 124, 32, 2399, 1, 4294967295, 4294967295, 1, 124, 8, 2400, 1, 4294967295, 4294967295, 5, 124, 8, 2401, 1, 1800, 4294967295, 8, 124, 8, 2402, 1, 4294967295, 4294967295, 10, 124, 8, 2403, 2, 4294967295, 4294967295, 12, 124, 8, 2405, 1, 4294967295, 1803, 9, 124, 8, 2406, 1, 4294967295, 4294967295, 1, 124, 32, 2407, 1, 4294967295, 4294967295, 1, 124, 8, 2408, 1, 4294967295, 4294967295, 1, 125, 8, 2409, 1, 4294967295, 4294967295, 1, 125, 32, 2410, 1, 4294967295, 4294967295, 1, 125, 8, 2411, 1, 4294967295, 4294967295, 3, 125, 8, 2412, 2, 1810, 4294967295, 8, 125, 8, 2414, 1, 4294967295, 4294967295, 1, 125, 8, 2415, 1, 4294967295, 4294967295, 1, 125, 8, 2416, 1, 4294967295, 4294967295, 3, 125, 8, 2417, 2, 1814, 4294967295, 8, 125, 8, 2419, 1, 4294967295, 4294967295, 3, 125, 8, 2420, 2, 1816, 4294967295, 8, 125, 8, 2422, 1, 4294967295, 4294967295, 1, 126, 32, 2423, 1, 4294967295, 4294967295, 1, 126, 8, 2424, 1, 4294967295, 4294967295, 1, 126, 8, 2425, 1, 4294967295, 4294967295, 1, 126, 8, 2426, 1, 4294967295, 4294967295, 1, 126, 8, 2427, 1, 4294967295, 4294967295, 3, 126, 8, 2428, 2, 1823, 4294967295, 8, 126, 8, 2430, 1, 4294967295, 4294967295, 1, 127, 32, 2431, 1, 4294967295, 4294967295, 1, 127, 8, 2432, 1, 4294967295, 4294967295, 3, 127, 8, 2433, 2, 1827, 4294967295, 8, 127, 8, 2435, 1, 4294967295, 4294967295, 1, 127, 32, 2436, 1, 4294967295, 4294967295, 1, 127, 8, 2437, 1, 4294967295, 4294967295, 1, 127, 0, 2438, 0, 4294967295, 4294967295, 1, 277, 0, 0, 0, 1, 282, 0, 0, 0, 1, 275, 0, 0, 0, 1, 290, 0, 0, 0, 1, 258, 0, 0, 0, 1, 297, 0, 0, 0, 1, 262, 0, 0, 0, 1, 281, 0, 0, 0, 1, 311, 0, 0, 0, 1, 269, 0, 0, 0, 1, 326, 0, 0, 0, 1, 485, 0, 0, 0, 1, 544, 0, 0, 0, 1, 557, 0, 0, 0, 1, 923, 0, 0, 0, 1, 338, 0, 0, 0, 1, 310, 0, 0, 0, 1, 327, 0, 0, 0, 1, 1147, 0, 0, 0, 1, 342, 0, 0, 0, 1, 786, 0, 0, 0, 1, 812, 0, 0, 0, 1, 1127, 0, 0, 0, 1, 1286, 0, 0, 0, 1, 1323, 0, 0, 0, 1, 1383, 0, 0, 0, 1, 1543, 0, 0, 0, 1, 344, 0, 0, 0, 1, 320, 0, 0, 0, 1, 503, 0, 0, 0, 1, 574, 0, 0, 0, 1, 937, 0, 0, 0, 1, 1156, 0, 0, 0, 1, 363, 0, 0, 0, 1, 348, 0, 0, 0, 1, 449, 0, 0, 0, 1, 529, 0, 0, 0, 1, 532, 0, 0, 0, 1, 620, 0, 0, 0, 1, 1057, 0, 0, 0, 1, 377, 0, 0, 0, 1, 369, 0, 0, 0, 1, 368, 0, 0, 0, 1, 391, 0, 0, 0, 1, 390, 0, 0, 0, 1, 399, 0, 0, 0, 1, 320, 0, 0, 0, 1, 503, 0, 0, 0, 1, 574, 0, 0, 0, 1, 945, 0, 0, 0, 1, 1156, 0, 0, 0, 1, 417, 0, 0, 0, 1, 408, 0, 0, 0, 1, 428, 0, 0, 0, 1, 422, 0, 0, 0, 1, 421, 0, 0, 0, 1, 438, 0, 0, 0, 1, 414, 0, 0, 0, 1, 445, 0, 0, 0, 1, 320, 0, 0, 0, 1, 503, 0, 0, 0, 1, 574, 0, 0, 0, 1, 941, 0, 0, 0, 1, 1156, 0, 0, 0, 1, 460, 0, 0, 0, 1, 362, 0, 0, 0, 1, 437, 0, 0, 0, 1, 1744, 0, 0, 0, 1, 469, 0, 0, 0, 1, 459, 0, 0, 0, 1, 490, 0, 0, 0, 1, 441, 0, 0, 0, 1, 463, 0, 0, 0, 1, 1103, 0, 0, 0, 1, 502, 0, 0, 0, 1, 491, 0, 0, 0, 1, 504, 0, 0, 0, 1, 503, 0, 0, 0, 1, 530, 0, 0, 0, 1, 522, 0, 0, 0, 1, 519, 0, 0, 0, 1, 643, 0, 0, 0, 1, 526, 0, 0, 0, 1, 505, 0, 0, 0, 1, 629, 0, 0, 0, 1, 1616, 0, 0, 0, 1, 528, 0, 0, 0, 1, 503, 0, 0, 0, 1, 531, 0, 0, 0, 1, 503, 0, 0, 0, 1, 534, 0, 0, 0, 1, 503, 0, 0, 0, 1, 533, 0, 0, 0, 1, 545, 0, 0, 0, 1, 1103, 0, 0, 0, 1, 551, 0, 0, 0, 1, 503, 0, 0, 0, 1, 563, 0, 0, 0, 1, 472, 0, 0, 0, 1, 573, 0, 0, 0, 1, 564, 0, 0, 0, 1, 575, 0, 0, 0, 1, 574, 0, 0, 0, 1, 586, 0, 0, 0, 1, 581, 0, 0, 0, 1, 580, 0, 0, 0, 1, 600, 0, 0, 0, 1, 574, 0, 0, 0, 1, 611, 0, 0, 0, 1, 599, 0, 0, 0, 1, 615, 0, 0, 0, 1, 616, 0, 0, 0, 1, 574, 0, 0, 0, 1, 625, 0, 0, 0, 1, 604, 0, 0, 0, 1, 621, 0, 0, 0, 1, 644, 0, 0, 0, 1, 553, 0, 0, 0, 1, 968, 0, 0, 0, 1, 1138, 0, 0, 0, 1, 1555, 0, 0, 0, 1, 652, 0, 0, 0, 1, 649, 0, 0, 0, 1, 648, 0, 0, 0, 1, 657, 0, 0, 0, 1, 655, 0, 0, 0, 1, 801, 0, 0, 0, 1, 1329, 0, 0, 0, 1, 1392, 0, 0, 0, 1, 667, 0, 0, 0, 1, 596, 0, 0, 0, 1, 656, 0, 0, 0, 1, 675, 0, 0, 0, 1, 674, 0, 0, 0, 1, 669, 0, 0, 0, 1, 668, 0, 0, 0, 1, 1740, 0, 0, 0, 1, 699, 0, 0, 0, 1, 1423, 0, 0, 0, 1, 1682, 0, 0, 0, 1, 719, 0, 0, 0, 1, 686, 0, 0, 0, 1, 739, 0, 0, 0, 1, 1801, 0, 0, 0, 1, 1800, 0, 0, 0, 1, 741, 0, 0, 0, 1, 517, 0, 0, 0, 1, 539, 0, 0, 0, 1, 641, 0, 0, 0, 1, 749, 0, 0, 0, 1, 511, 0, 0, 0, 1, 538, 0, 0, 0, 1, 635, 0, 0, 0, 1, 765, 0, 0, 0, 1, 753, 0, 0, 0, 1, 776, 0, 0, 0, 1, 757, 0, 0, 0, 1, 1583, 0, 0, 0, 1, 787, 0, 0, 0, 1, 753, 0, 0, 0, 1, 781, 0, 0, 0, 1, 780, 0, 0, 0, 1, 802, 0, 0, 0, 1, 1599, 0, 0, 0, 1, 813, 0, 0, 0, 1, 807, 0, 0, 0, 1, 806, 0, 0, 0, 1, 819, 0, 0, 0, 1, 295, 0, 0, 0, 1, 304, 0, 0, 0, 1, 746, 0, 0, 0, 1, 745, 0, 0, 0, 1, 842, 0, 0, 0, 1, 983, 0, 0, 0, 1, 1000, 0, 0, 0, 1, 1013, 0, 0, 0, 1, 1010, 0, 0, 0, 1, 1009, 0, 0, 0, 1, 1028, 0, 0, 0, 1, 1025, 0, 0, 0, 1, 1024, 0, 0, 0, 1, 1034, 0, 0, 0, 1, 1038, 0, 0, 0, 1, 1044, 0, 0, 0, 1, 1043, 0, 0, 0, 1, 1300, 0, 0, 0, 1, 1299, 0, 0, 0, 1, 1339, 0, 0, 0, 1, 834, 0, 0, 0, 1, 1626, 0, 0, 0, 1, 836, 0, 0, 0, 1, 835, 0, 0, 0, 1, 838, 0, 0, 0, 1, 835, 0, 0, 0, 1, 840, 0, 0, 0, 1, 289, 0, 0, 0, 1, 339, 0, 0, 0, 1, 343, 0, 0, 0, 1, 376, 0, 0, 0, 1, 384, 0, 0, 0, 1, 427, 0, 0, 0, 1, 612, 0, 0, 0, 1, 624, 0, 0, 0, 1, 689, 0, 0, 0, 1, 706, 0, 0, 0, 1, 730, 0, 0, 0, 1, 793, 0, 0, 0, 1, 885, 0, 0, 0, 1, 890, 0, 0, 0, 1, 974, 0, 0, 0, 1, 1083, 0, 0, 0, 1, 1090, 0, 0, 0, 1, 1435, 0, 0, 0, 1, 1550, 0, 0, 0, 1, 1772, 0, 0, 0, 1, 1782, 0, 0, 0, 1, 846, 0, 0, 0, 1, 845, 0, 0, 0, 1, 865, 0, 0, 0, 1, 852, 0, 0, 0, 1, 851, 0, 0, 0, 1, 884, 0, 0, 0, 1, 866, 0, 0, 0, 1, 864, 0, 0, 0, 1, 875, 0, 0, 0, 1, 874, 0, 0, 0, 1, 889, 0, 0, 0, 1, 897, 0, 0, 0, 1, 896, 0, 0, 0, 1, 971, 0, 0, 0, 1, 891, 0, 0, 0, 1, 890, 0, 0, 0, 1, 907, 0, 0, 0, 1, 320, 0, 0, 0, 1, 503, 0, 0, 0, 1, 574, 0, 0, 0, 1, 949, 0, 0, 0, 1, 912, 0, 0, 0, 1, 911, 0, 0, 0, 1, 929, 0, 0, 0, 1, 915, 0, 0, 0, 1, 955, 0, 0, 0, 1, 930, 0, 0, 0, 1, 959, 0, 0, 0, 1, 933, 0, 0, 0, 1, 961, 0, 0, 0, 1, 960, 0, 0, 0, 1, 967, 0, 0, 0, 1, 960, 0, 0, 0, 1, 969, 0, 0, 0, 1, 966, 0, 0, 0, 1, 975, 0, 0, 0, 1, 286, 0, 0, 0, 1, 1049, 0, 0, 0, 1, 986, 0, 0, 0, 1, 1051, 0, 0, 0, 1, 995, 0, 0, 0, 1, 1053, 0, 0, 0, 1, 320, 0, 0, 0, 1, 503, 0, 0, 0, 1, 574, 0, 0, 0, 1, 953, 0, 0, 0, 1, 1156, 0, 0, 0, 1, 1065, 0, 0, 0, 1, 1061, 0, 0, 0, 1, 1071, 0, 0, 0, 1, 1068, 0, 0, 0, 1, 1084, 0, 0, 0, 1, 1076, 0, 0, 0, 1, 1075, 0, 0, 0, 1, 1099, 0, 0, 0, 1, 1064, 0, 0, 0, 1, 1109, 0, 0, 0, 1, 491, 0, 0, 0, 1, 523, 0, 0, 0, 1, 541, 0, 0, 0, 1, 550, 0, 0, 0, 1, 1281, 0, 0, 0, 1, 1206, 0, 0, 0, 1, 1214, 0, 0, 0, 1, 1244, 0, 0, 0, 1, 1294, 0, 0, 0, 1, 1305, 0, 0, 0, 1, 1606, 0, 0, 0, 1, 1680, 0, 0, 0, 1, 1123, 0, 0, 0, 1, 1112, 0, 0, 0, 1, 1349, 0, 0, 0, 1, 1675, 0, 0, 0, 1, 1128, 0, 0, 0, 1, 1119, 0, 0, 0, 1, 1380, 0, 0, 0, 1, 1141, 0, 0, 0, 1, 347, 0, 0, 0, 1, 389, 0, 0, 0, 1, 403, 0, 0, 0, 1, 433, 0, 0, 0, 1, 448, 0, 0, 0, 1, 506, 0, 0, 0, 1, 535, 0, 0, 0, 1, 549, 0, 0, 0, 1, 591, 0, 0, 0, 1, 630, 0, 0, 0, 1, 662, 0, 0, 0, 1, 724, 0, 0, 0, 1, 723, 0, 0, 0, 1, 767, 0, 0, 0, 1, 818, 0, 0, 0, 1, 824, 0, 0, 0, 1, 823, 0, 0, 0, 1, 862, 0, 0, 0, 1, 910, 0, 0, 0, 1, 962, 0, 0, 0, 1, 1056, 0, 0, 0, 1, 1098, 0, 0, 0, 1, 1133, 0, 0, 0, 1, 1257, 0, 0, 0, 1, 1262, 0, 0, 0, 1, 1277, 0, 0, 0, 1, 1292, 0, 0, 0, 1, 1333, 0, 0, 0, 1, 1357, 0, 0, 0, 1, 1407, 0, 0, 0, 1, 1421, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1537, 0, 0, 0, 1, 1602, 0, 0, 0, 1, 1591, 0, 0, 0, 1, 1590, 0, 0, 0, 1, 1626, 0, 0, 0, 1, 1696, 0, 0, 0, 1, 1701, 0, 0, 0, 1, 1713, 0, 0, 0, 1, 1813, 0, 0, 0, 1, 1820, 0, 0, 0, 1, 1143, 0, 0, 0, 1, 697, 0, 0, 0, 1, 712, 0, 0, 0, 1, 1148, 0, 0, 0, 1, 1124, 0, 0, 0, 1, 1280, 0, 0, 0, 1, 1124, 0, 0, 0, 1, 1173, 0, 0, 0, 1, 1174, 0, 0, 0, 1, 1180, 0, 0, 0, 1, 1186, 0, 0, 0, 1, 1189, 0, 0, 0, 1, 1279, 0, 0, 0, 1, 1282, 0, 0, 0, 1, 1199, 0, 0, 0, 1, 1213, 0, 0, 0, 1, 1295, 0, 0, 0, 1, 1291, 0, 0, 0, 1, 1303, 0, 0, 0, 1, 1204, 0, 0, 0, 1, 1207, 0, 0, 0, 1, 1219, 0, 0, 0, 1, 1306, 0, 0, 0, 1, 1210, 0, 0, 0, 1, 1313, 0, 0, 0, 1, 1309, 0, 0, 0, 1, 1338, 0, 0, 0, 1, 1318, 0, 0, 0, 1, 1317, 0, 0, 0, 1, 1343, 0, 0, 0, 1, 1227, 0, 0, 0, 1, 1361, 0, 0, 0, 1, 1233, 0, 0, 0, 1, 1341, 0, 0, 0, 1, 1375, 0, 0, 0, 1, 1178, 0, 0, 0, 1, 1379, 0, 0, 0, 1, 1366, 0, 0, 0, 1, 1384, 0, 0, 0, 1, 1376, 0, 0, 0, 1, 1395, 0, 0, 0, 1, 1374, 0, 0, 0, 1, 1380, 0, 0, 0, 1, 1659, 0, 0, 0, 1, 1827, 0, 0, 0, 1, 1406, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1453, 0, 0, 0, 1, 668, 0, 0, 0, 1, 885, 0, 0, 0, 1, 890, 0, 0, 0, 1, 1135, 0, 0, 0, 1, 1162, 0, 0, 0, 1, 1163, 0, 0, 0, 1, 1169, 0, 0, 0, 1, 1184, 0, 0, 0, 1, 1192, 0, 0, 0, 1, 1223, 0, 0, 0, 1, 1242, 0, 0, 0, 1, 1248, 0, 0, 0, 1, 1252, 0, 0, 0, 1, 1266, 0, 0, 0, 1, 1270, 0, 0, 0, 1, 1336, 0, 0, 0, 1, 1359, 0, 0, 0, 1, 1370, 0, 0, 0, 1, 1394, 0, 0, 0, 1, 1400, 0, 0, 0, 1, 1399, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1449, 0, 0, 0, 1, 1458, 0, 0, 0, 1, 1537, 0, 0, 0, 1, 1530, 0, 0, 0, 1, 1532, 0, 0, 0, 1, 1606, 0, 0, 0, 1, 1609, 0, 0, 0, 1, 1630, 0, 0, 0, 1, 1669, 0, 0, 0, 1, 1726, 0, 0, 0, 1, 1563, 0, 0, 0, 1, 1508, 0, 0, 0, 1, 1574, 0, 0, 0, 1, 1671, 0, 0, 0, 1, 1565, 0, 0, 0, 1, 1560, 0, 0, 0, 1, 1573, 0, 0, 0, 1, 1570, 0, 0, 0, 1, 1569, 0, 0, 0, 1, 1575, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1601, 0, 0, 0, 1, 1576, 0, 0, 0, 1, 1605, 0, 0, 0, 1, 1578, 0, 0, 0, 1, 1625, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1627, 0, 0, 0, 1, 1274, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1665, 0, 0, 0, 1, 1634, 0, 0, 0, 1, 1667, 0, 0, 0, 1, 1657, 0, 0, 0, 1, 1670, 0, 0, 0, 1, 1652, 0, 0, 0, 1, 1651, 0, 0, 0, 1, 1679, 0, 0, 0, 1, 1666, 0, 0, 0, 1, 1681, 0, 0, 0, 1, 1328, 0, 0, 0, 1, 1779, 0, 0, 0, 1, 1692, 0, 0, 0, 1, 1454, 0, 0, 0, 1, 1709, 0, 0, 0, 1, 1687, 0, 0, 0, 1, 1690, 0, 0, 0, 1, 1711, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1739, 0, 0, 0, 1, 1691, 0, 0, 0, 1, 1741, 0, 0, 0, 1, 1688, 0, 0, 0, 1, 1716, 0, 0, 0, 1, 1745, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1751, 0, 0, 0, 1, 1697, 0, 0, 0, 1, 1702, 0, 0, 0, 1, 1756, 0, 0, 0, 1, 1714, 0, 0, 0, 1, 1758, 0, 0, 0, 1, 1468, 0, 0, 0, 1, 1623, 0, 0, 0, 1, 1685, 0, 0, 0, 1, 1746, 0, 0, 0, 1, 1757, 0, 0, 0, 1, 1762, 0, 0, 0, 1, 356, 0, 0, 0, 1, 360, 0, 0, 0, 1, 404, 0, 0, 0, 1, 453, 0, 0, 0, 1, 457, 0, 0, 0, 1, 1062, 0, 0, 0, 1, 1760, 0, 0, 0, 1, 1773, 0, 0, 0, 1, 352, 0, 0, 0, 1, 396, 0, 0, 0, 1, 395, 0, 0, 0, 1, 527, 0, 0, 0, 1, 552, 0, 0, 0, 1, 576, 0, 0, 0, 1, 740, 0, 0, 0, 1, 738, 0, 0, 0, 1, 771, 0, 0, 0, 1, 798, 0, 0, 0, 1, 932, 0, 0, 0, 1, 1095, 0, 0, 0, 1, 1137, 0, 0, 0, 1, 1356, 0, 0, 0, 1, 1390, 0, 0, 0, 1, 1414, 0, 0, 0, 1, 1444, 0, 0, 0, 1, 1443, 0, 0, 0, 1, 1508, 0, 0, 0, 1, 1551, 0, 0, 0, 1, 1557, 0, 0, 0, 1, 1767, 0, 0, 0, 1, 1766, 0, 0, 0, 1, 1793, 0, 0, 0, 1, 1710, 0, 0, 0, 1, 1779, 0, 0, 0, 1, 1795, 0, 0, 0, 1, 698, 0, 0, 0, 1, 713, 0, 0, 0, 1, 1417, 0, 0, 0, 1, 1426, 0, 0, 0, 1, 1479, 0, 0, 0, 1, 1752, 0, 0, 0, 1, 1810, 0, 0, 0, 1, 1815, 0, 0, 0, 1, 1474, 0, 0, 0, 1, 1823, 0, 0, 0, 1, 1822, 0, 0, 0, 1, 1624, 0, 0, 0, 1, 1747, 0, 0, 0, 1, 1824, 0, 0, 0, 1, 434, 0, 0, 0, 1, 1409, 0, 0, 0, 1, 1624, 0, 0, 0, 1, 1743, 0, 0, 0, 1, 1816, 0, 0, 0, 1, 1814, 0, 0, 0, 1, 1821, 0, 0, 0, 3, 4, 2, 258, 0, 1, 256, 0, 0, 0, 1, 258, 0, 0, 0, 1, 263, 0, 0, 0, 3, 6, 3, 262, 0, 5, 262, 85, 0, 0, 1, 259, 0, 0, 0, 1, 260, 0, 0, 0, 1, 265, 0, 0, 0, 1, 261, 0, 0, 0, 1, 264, 0, 0, 0, 1, 270, 0, 0, 0, 1, 263, 0, 0, 0, 3, 8, 4, 269, 0, 5, 269, 85, 0, 0, 1, 266, 0, 0, 0, 1, 267, 0, 0, 0, 1, 272, 0, 0, 0, 1, 268, 0, 0, 0, 1, 271, 0, 0, 0, 1, 273, 0, 0, 0, 1, 270, 0, 0, 0, 5, 278, 4294967295, 0, 0, 3, 2, 1, 275, 0, 5, 276, 4294967295, 0, 0, 1, 278, 0, 0, 0, 1, 257, 0, 0, 0, 1, 274, 0, 0, 0, 1, 1, 0, 0, 0, 3, 6, 3, 281, 0, 1, 279, 0, 0, 0, 1, 284, 0, 0, 0, 1, 280, 0, 0, 0, 1, 283, 0, 0, 0, 1, 285, 0, 0, 0, 1, 282, 0, 0, 0, 3, 140, 70, 286, 0, 1, 3, 0, 0, 0, 3, 112, 56, 289, 0, 1, 287, 0, 0, 0, 1, 292, 0, 0, 0, 1, 288, 0, 0, 0, 1, 291, 0, 0, 0, 1, 293, 0, 0, 0, 1, 290, 0, 0, 0, 5, 294, 37, 0, 0, 3, 104, 52, 295, 0, 5, 296, 85, 0, 0, 1, 5, 0, 0, 0, 5, 299, 26, 0, 0, 5, 300, 48, 0, 0, 1, 298, 0, 0, 0, 1, 300, 0, 0, 0, 1, 301, 0, 0, 0, 3, 104, 52, 304, 0, 5, 303, 87, 0, 0, 5, 305, 105, 0, 0, 1, 302, 0, 0, 0, 1, 305, 0, 0, 0, 1, 306, 0, 0, 0, 5, 307, 85, 0, 0, 1, 7, 0, 0, 0, 3, 12, 6, 310, 0, 1, 308, 0, 0, 0, 1, 313, 0, 0, 0, 1, 309, 0, 0, 0, 1, 312, 0, 0, 0, 1, 319, 0, 0, 0, 1, 311, 0, 0, 0, 3, 16, 8, 320, 0, 3, 24, 12, 320, 0, 3, 32, 16, 320, 0, 3, 124, 62, 320, 0, 3, 146, 73, 320, 0, 1, 314, 0, 0, 0, 1, 315, 0, 0, 0, 1, 316, 0, 0, 0, 1, 317, 0, 0, 0, 1, 318, 0, 0, 0, 1, 9, 0, 0, 0, 3, 12, 6, 327, 0, 5, 327, 32, 0, 0, 5, 327, 52, 0, 0, 5, 327, 57, 0, 0, 5, 327, 63, 0, 0, 1, 321, 0, 0, 0, 1, 322, 0, 0, 0, 1, 323, 0, 0, 0, 1, 324, 0, 0, 0, 1, 325, 0, 0, 0, 1, 11, 0, 0, 0, 3, 112, 56, 339, 0, 5, 339, 42, 0, 0, 5, 339, 40, 0, 0, 5, 339, 39, 0, 0, 5, 339, 48, 0, 0, 5, 339, 1, 0, 0, 5, 339, 19, 0, 0, 5, 339, 49, 0, 0, 5, 339, 46, 0, 0, 5, 339, 34, 0, 0, 1, 328, 0, 0, 0, 1, 329, 0, 0, 0, 1, 330, 0, 0, 0, 1, 331, 0, 0, 0, 1, 332, 0, 0, 0, 1, 333, 0, 0, 0, 1, 334, 0, 0, 0, 1, 335, 0, 0, 0, 1, 336, 0, 0, 0, 1, 337, 0, 0, 0, 1, 13, 0, 0, 0, 5, 343, 19, 0, 0, 3, 112, 56, 343, 0, 1, 340, 0, 0, 0, 1, 341, 0, 0, 0, 1, 15, 0, 0, 0, 5, 345, 9, 0, 0, 3, 162, 81, 347, 0, 3, 18, 9, 348, 0, 1, 346, 0, 0, 0, 1, 348, 0, 0, 0, 1, 351, 0, 0, 0, 5, 350, 18, 0, 0, 3, 244, 122, 352, 0, 1, 349, 0, 0, 0, 1, 352, 0, 0, 0, 1, 355, 0, 0, 0, 5, 354, 25, 0, 0, 3, 242, 121, 356, 0, 1, 353, 0, 0, 0, 1, 356, 0, 0, 0, 1, 359, 0, 0, 0, 5, 358, 38, 0, 0, 3, 242, 121, 360, 0, 1, 357, 0, 0, 0, 1, 360, 0, 0, 0, 1, 361, 0, 0, 0, 3, 34, 17, 362, 0, 1, 17, 0, 0, 0, 5, 364, 90, 0, 0, 3, 20, 10, 369, 0, 5, 366, 86, 0, 0, 3, 20, 10, 368, 0, 1, 365, 0, 0, 0, 1, 371, 0, 0, 0, 1, 367, 0, 0, 0, 1, 370, 0, 0, 0, 1, 372, 0, 0, 0, 1, 369, 0, 0, 0, 5, 373, 89, 0, 0, 1, 19, 0, 0, 0, 3, 112, 56, 376, 0, 1, 374, 0, 0, 0, 1, 379, 0, 0, 0, 1, 375, 0, 0, 0, 1, 378, 0, 0, 0, 1, 380, 0, 0, 0, 1, 377, 0, 0, 0, 3, 162, 81, 389, 0, 5, 385, 18, 0, 0, 3, 112, 56, 384, 0, 1, 382, 0, 0, 0, 1, 387, 0, 0, 0, 1, 383, 0, 0, 0, 1, 386, 0, 0, 0, 1, 388, 0, 0, 0, 1, 385, 0, 0, 0, 3, 22, 11, 390, 0, 1, 381, 0, 0, 0, 1, 390, 0, 0, 0, 1, 21, 0, 0, 0, 3, 244, 122, 396, 0, 5, 393, 107, 0, 0, 3, 244, 122, 395, 0, 1, 392, 0, 0, 0, 1, 398, 0, 0, 0, 1, 394, 0, 0, 0, 1, 397, 0, 0, 0, 1, 23, 0, 0, 0, 1, 396, 0, 0, 0, 5, 400, 16, 0, 0, 3, 162, 81, 403, 0, 5, 402, 25, 0, 0, 3, 242, 121, 404, 0, 1, 401, 0, 0, 0, 1, 404, 0, 0, 0, 1, 405, 0, 0, 0, 5, 407, 81, 0, 0, 3, 26, 13, 408, 0, 1, 406, 0, 0, 0, 1, 408, 0, 0, 0, 1, 410, 0, 0, 0, 5, 411, 86, 0, 0, 1, 409, 0, 0, 0, 1, 411, 0, 0, 0, 1, 413, 0, 0, 0, 3, 30, 15, 414, 0, 1, 412, 0, 0, 0, 1, 414, 0, 0, 0, 1, 415, 0, 0, 0, 5, 416, 82, 0, 0, 1, 25, 0, 0, 0, 3, 28, 14, 422, 0, 5, 419, 86, 0, 0, 3, 28, 14, 421, 0, 1, 418, 0, 0, 0, 1, 424, 0, 0, 0, 1, 420, 0, 0, 0, 1, 423, 0, 0, 0, 1, 27, 0, 0, 0, 1, 422, 0, 0, 0, 3, 112, 56, 427, 0, 1, 425, 0, 0, 0, 1, 430, 0, 0, 0, 1, 426, 0, 0, 0, 1, 429, 0, 0, 0, 1, 431, 0, 0, 0, 1, 428, 0, 0, 0, 3, 162, 81, 433, 0, 3, 254, 127, 434, 0, 1, 432, 0, 0, 0, 1, 434, 0, 0, 0, 1, 436, 0, 0, 0, 3, 34, 17, 437, 0, 1, 435, 0, 0, 0, 1, 437, 0, 0, 0, 1, 29, 0, 0, 0, 5, 442, 85, 0, 0, 3, 38, 19, 441, 0, 1, 439, 0, 0, 0, 1, 444, 0, 0, 0, 1, 440, 0, 0, 0, 1, 443, 0, 0, 0, 1, 31, 0, 0, 0, 1, 442, 0, 0, 0, 5, 446, 29, 0, 0, 3, 162, 81, 448, 0, 3, 18, 9, 449, 0, 1, 447, 0, 0, 0, 1, 449, 0, 0, 0, 1, 452, 0, 0, 0, 5, 451, 18, 0, 0, 3, 242, 121, 453, 0, 1, 450, 0, 0, 0, 1, 453, 0, 0, 0, 1, 456, 0, 0, 0, 5, 455, 38, 0, 0, 3, 242, 121, 457, 0, 1, 454, 0, 0, 0, 1, 457, 0, 0, 0, 1, 458, 0, 0, 0, 3, 36, 18, 459, 0, 1, 33, 0, 0, 0, 5, 464, 81, 0, 0, 3, 38, 19, 463, 0, 1, 461, 0, 0, 0, 1, 466, 0, 0, 0, 1, 462, 0, 0, 0, 1, 465, 0, 0, 0, 1, 467, 0, 0, 0, 1, 464, 0, 0, 0, 5, 468, 82, 0, 0, 1, 35, 0, 0, 0, 5, 473, 81, 0, 0, 3, 58, 29, 472, 0, 1, 470, 0, 0, 0, 1, 475, 0, 0, 0, 1, 471, 0, 0, 0, 1, 474, 0, 0, 0, 1, 476, 0, 0, 0, 1, 473, 0, 0, 0, 5, 477, 82, 0, 0, 1, 37, 0, 0, 0, 5, 491, 85, 0, 0, 5, 481, 48, 0, 0, 1, 479, 0, 0, 0, 1, 481, 0, 0, 0, 1, 482, 0, 0, 0, 3, 156, 78, 491, 0, 3, 10, 5, 485, 0, 1, 483, 0, 0, 0, 1, 488, 0, 0, 0, 1, 484, 0, 0, 0, 1, 487, 0, 0, 0, 1, 489, 0, 0, 0, 1, 486, 0, 0, 0, 3, 40, 20, 491, 0, 1, 478, 0, 0, 0, 1, 480, 0, 0, 0, 1, 486, 0, 0, 0, 1, 39, 0, 0, 0, 3, 146, 73, 503, 0, 3, 42, 21, 503, 0, 3, 48, 24, 503, 0, 3, 56, 28, 503, 0, 3, 52, 26, 503, 0, 3, 50, 25, 503, 0, 3, 32, 16, 503, 0, 3, 124, 62, 503, 0, 3, 16, 8, 503, 0, 3, 24, 12, 503, 0, 1, 492, 0, 0, 0, 1, 493, 0, 0, 0, 1, 494, 0, 0, 0, 1, 495, 0, 0, 0, 1, 496, 0, 0, 0, 1, 497, 0, 0, 0, 1, 498, 0, 0, 0, 1, 499, 0, 0, 0, 1, 500, 0, 0, 0, 1, 501, 0, 0, 0, 1, 41, 0, 0, 0, 3, 46, 23, 505, 0, 3, 162, 81, 506, 0, 3, 92, 46, 511, 0, 5, 508, 83, 0, 0, 5, 510, 84, 0, 0, 1, 507, 0, 0, 0, 1, 513, 0, 0, 0, 1, 509, 0, 0, 0, 1, 512, 0, 0, 0, 1, 516, 0, 0, 0, 1, 511, 0, 0, 0, 5, 515, 55, 0, 0, 3, 90, 45, 517, 0, 1, 514, 0, 0, 0, 1, 517, 0, 0, 0, 1, 518, 0, 0, 0, 3, 44, 22, 519, 0, 1, 43, 0, 0, 0, 3, 156, 78, 523, 0, 5, 523, 85, 0, 0, 1, 520, 0, 0, 0, 1, 521, 0, 0, 0, 1, 45, 0, 0, 0, 3, 244, 122, 527, 0, 5, 527, 62, 0, 0, 1, 524, 0, 0, 0, 1, 525, 0, 0, 0, 1, 47, 0, 0, 0, 3, 18, 9, 529, 0, 3, 42, 21, 530, 0, 1, 49, 0, 0, 0, 3, 18, 9, 532, 0, 3, 52, 26, 533, 0, 1, 51, 0, 0, 0, 3, 162, 81, 535, 0, 3, 92, 46, 538, 0, 5, 537, 55, 0, 0, 3, 90, 45, 539, 0, 1, 536, 0, 0, 0, 1, 539, 0, 0, 0, 1, 540, 0, 0, 0, 3, 156, 78, 541, 0, 1, 53, 0, 0, 0, 3, 10, 5, 544, 0, 1, 542, 0, 0, 0, 1, 547, 0, 0, 0, 1, 543, 0, 0, 0, 1, 546, 0, 0, 0, 1, 548, 0, 0, 0, 1, 545, 0, 0, 0, 3, 162, 81, 549, 0, 3, 156, 78, 550, 0, 1, 55, 0, 0, 0, 3, 244, 122, 552, 0, 3, 74, 37, 553, 0, 5, 554, 85, 0, 0, 1, 57, 0, 0, 0, 3, 10, 5, 557, 0, 1, 555, 0, 0, 0, 1, 560, 0, 0, 0, 1, 556, 0, 0, 0, 1, 559, 0, 0, 0, 1, 561, 0, 0, 0, 1, 558, 0, 0, 0, 3, 60, 30, 564, 0, 5, 564, 85, 0, 0, 1, 558, 0, 0, 0, 1, 562, 0, 0, 0, 1, 59, 0, 0, 0, 3, 146, 73, 574, 0, 3, 62, 31, 574, 0, 3, 66, 33, 574, 0, 3, 70, 35, 574, 0, 3, 32, 16, 574, 0, 3, 124, 62, 574, 0, 3, 16, 8, 574, 0, 3, 24, 12, 574, 0, 1, 565, 0, 0, 0, 1, 566, 0, 0, 0, 1, 567, 0, 0, 0, 1, 568, 0, 0, 0, 1, 569, 0, 0, 0, 1, 570, 0, 0, 0, 1, 571, 0, 0, 0, 1, 572, 0, 0, 0, 1, 61, 0, 0, 0, 3, 244, 122, 576, 0, 3, 64, 32, 581, 0, 5, 578, 86, 0, 0, 3, 64, 32, 580, 0, 1, 577, 0, 0, 0, 1, 583, 0, 0, 0, 1, 579, 0, 0, 0, 1, 582, 0, 0, 0, 1, 584, 0, 0, 0, 1, 581, 0, 0, 0, 5, 585, 85, 0, 0, 1, 63, 0, 0, 0, 3, 162, 81, 591, 0, 5, 588, 83, 0, 0, 5, 590, 84, 0, 0, 1, 587, 0, 0, 0, 1, 593, 0, 0, 0, 1, 589, 0, 0, 0, 1, 592, 0, 0, 0, 1, 594, 0, 0, 0, 1, 591, 0, 0, 0, 5, 595, 88, 0, 0, 3, 80, 40, 596, 0, 1, 65, 0, 0, 0, 3, 68, 34, 599, 0, 1, 597, 0, 0, 0, 1, 602, 0, 0, 0, 1, 598, 0, 0, 0, 1, 601, 0, 0, 0, 1, 603, 0, 0, 0, 1, 600, 0, 0, 0, 3, 72, 36, 604, 0, 1, 67, 0, 0, 0, 3, 112, 56, 612, 0, 5, 612, 42, 0, 0, 5, 612, 1, 0, 0, 5, 612, 12, 0, 0, 5, 612, 48, 0, 0, 5, 612, 49, 0, 0, 1, 605, 0, 0, 0, 1, 606, 0, 0, 0, 1, 607, 0, 0, 0, 1, 608, 0, 0, 0, 1, 609, 0, 0, 0, 1, 610, 0, 0, 0, 1, 69, 0, 0, 0, 3, 68, 34, 615, 0, 1, 613, 0, 0, 0, 1, 618, 0, 0, 0, 1, 614, 0, 0, 0, 1, 617, 0, 0, 0, 1, 619, 0, 0, 0, 1, 616, 0, 0, 0, 3, 18, 9, 620, 0, 3, 72, 36, 621, 0, 1, 71, 0, 0, 0, 3, 112, 56, 624, 0, 1, 622, 0, 0, 0, 1, 627, 0, 0, 0, 1, 623, 0, 0, 0, 1, 626, 0, 0, 0, 1, 628, 0, 0, 0, 1, 625, 0, 0, 0, 3, 46, 23, 629, 0, 3, 162, 81, 630, 0, 3, 92, 46, 635, 0, 5, 632, 83, 0, 0, 5, 634, 84, 0, 0, 1, 631, 0, 0, 0, 1, 637, 0, 0, 0, 1, 633, 0, 0, 0, 1, 636, 0, 0, 0, 1, 640, 0, 0, 0, 1, 635, 0, 0, 0, 5, 639, 55, 0, 0, 3, 90, 45, 641, 0, 1, 638, 0, 0, 0, 1, 641, 0, 0, 0, 1, 642, 0, 0, 0, 3, 44, 22, 643, 0, 1, 73, 0, 0, 0, 3, 76, 38, 649, 0, 5, 646, 86, 0, 0, 3, 76, 38, 648, 0, 1, 645, 0, 0, 0, 1, 651, 0, 0, 0, 1, 647, 0, 0, 0, 1, 650, 0, 0, 0, 1, 75, 0, 0, 0, 1, 649, 0, 0, 0, 3, 78, 39, 655, 0, 5, 654, 88, 0, 0, 3, 80, 40, 656, 0, 1, 653, 0, 0, 0, 1, 656, 0, 0, 0, 1, 77, 0, 0, 0, 3, 162, 81, 662, 0, 5, 659, 83, 0, 0, 5, 661, 84, 0, 0, 1, 658, 0, 0, 0, 1, 664, 0, 0, 0, 1, 660, 0, 0, 0, 1, 663, 0, 0, 0, 1, 79, 0, 0, 0, 1, 662, 0, 0, 0, 3, 82, 41, 668, 0, 3, 196, 98, 668, 0, 1, 665, 0, 0, 0, 1, 666, 0, 0, 0, 1, 81, 0, 0, 0, 5, 681, 81, 0, 0, 3, 80, 40, 675, 0, 5, 672, 86, 0, 0, 3, 80, 40, 674, 0, 1, 671, 0, 0, 0, 1, 677, 0, 0, 0, 1, 673, 0, 0, 0, 1, 676, 0, 0, 0, 1, 679, 0, 0, 0, 1, 675, 0, 0, 0, 5, 680, 86, 0, 0, 1, 678, 0, 0, 0, 1, 680, 0, 0, 0, 1, 682, 0, 0, 0, 1, 670, 0, 0, 0, 1, 682, 0, 0, 0, 1, 683, 0, 0, 0, 5, 684, 82, 0, 0, 1, 83, 0, 0, 0, 3, 86, 43, 686, 0, 5, 690, 87, 0, 0, 3, 112, 56, 689, 0, 1, 687, 0, 0, 0, 1, 692, 0, 0, 0, 1, 688, 0, 0, 0, 1, 691, 0, 0, 0, 1, 694, 0, 0, 0, 1, 690, 0, 0, 0, 1, 685, 0, 0, 0, 1, 694, 0, 0, 0, 1, 695, 0, 0, 0, 3, 164, 82, 697, 0, 3, 248, 124, 698, 0, 1, 696, 0, 0, 0, 1, 698, 0, 0, 0, 1, 700, 0, 0, 0, 1, 693, 0, 0, 0, 1, 701, 0, 0, 0, 1, 699, 0, 0, 0, 1, 702, 0, 0, 0, 1, 716, 0, 0, 0, 5, 707, 87, 0, 0, 3, 112, 56, 706, 0, 1, 704, 0, 0, 0, 1, 709, 0, 0, 0, 1, 705, 0, 0, 0, 1, 708, 0, 0, 0, 1, 710, 0, 0, 0, 1, 707, 0, 0, 0, 3, 164, 82, 712, 0, 3, 248, 124, 713, 0, 1, 711, 0, 0, 0, 1, 713, 0, 0, 0, 1, 715, 0, 0, 0, 1, 703, 0, 0, 0, 1, 718, 0, 0, 0, 1, 714, 0, 0, 0, 1, 717, 0, 0, 0, 1, 85, 0, 0, 0, 1, 716, 0, 0, 0, 3, 162, 81, 724, 0, 5, 721, 87, 0, 0, 3, 162, 81, 723, 0, 1, 720, 0, 0, 0, 1, 726, 0, 0, 0, 1, 722, 0, 0, 0, 1, 725, 0, 0, 0, 1, 87, 0, 0, 0, 1, 724, 0, 0, 0, 3, 244, 122, 740, 0, 3, 112, 56, 730, 0, 1, 728, 0, 0, 0, 1, 733, 0, 0, 0, 1, 729, 0, 0, 0, 1, 732, 0, 0, 0, 1, 734, 0, 0, 0, 1, 731, 0, 0, 0, 5, 737, 93, 0, 0, 7, 736, 0, 0, 0, 3, 244, 122, 738, 0, 1, 735, 0, 0, 0, 1, 738, 0, 0, 0, 1, 740, 0, 0, 0, 1, 727, 0, 0, 0, 1, 731, 0, 0, 0, 1, 89, 0, 0, 0, 3, 104, 52, 746, 0, 5, 743, 86, 0, 0, 3, 104, 52, 745, 0, 1, 742, 0, 0, 0, 1, 748, 0, 0, 0, 1, 744, 0, 0, 0, 1, 747, 0, 0, 0, 1, 91, 0, 0, 0, 1, 746, 0, 0, 0, 5, 761, 79, 0, 0, 3, 94, 47, 753, 0, 3, 98, 49, 753, 0, 1, 750, 0, 0, 0, 1, 751, 0, 0, 0, 1, 758, 0, 0, 0, 5, 755, 86, 0, 0, 3, 96, 48, 757, 0, 1, 754, 0, 0, 0, 1, 760, 0, 0, 0, 1, 756, 0, 0, 0, 1, 759, 0, 0, 0, 1, 762, 0, 0, 0, 1, 758, 0, 0, 0, 1, 752, 0, 0, 0, 1, 762, 0, 0, 0, 1, 763, 0, 0, 0, 5, 764, 80, 0, 0, 1, 93, 0, 0, 0, 3, 244, 122, 771, 0, 3, 162, 81, 767, 0, 5, 768, 87, 0, 0, 1, 770, 0, 0, 0, 1, 766, 0, 0, 0, 1, 773, 0, 0, 0, 1, 769, 0, 0, 0, 1, 772, 0, 0, 0, 1, 774, 0, 0, 0, 1, 771, 0, 0, 0, 5, 775, 53, 0, 0, 1, 95, 0, 0, 0, 3, 98, 49, 781, 0, 5, 778, 86, 0, 0, 3, 98, 49, 780, 0, 1, 777, 0, 0, 0, 1, 783, 0, 0, 0, 1, 779, 0, 0, 0, 1, 782, 0, 0, 0, 1, 97, 0, 0, 0, 1, 781, 0, 0, 0, 3, 14, 7, 786, 0, 1, 784, 0, 0, 0, 1, 789, 0, 0, 0, 1, 785, 0, 0, 0, 1, 788, 0, 0, 0, 1, 790, 0, 0, 0, 1, 787, 0, 0, 0, 3, 244, 122, 798, 0, 3, 112, 56, 793, 0, 1, 791, 0, 0, 0, 1, 796, 0, 0, 0, 1, 792, 0, 0, 0, 1, 795, 0, 0, 0, 1, 797, 0, 0, 0, 1, 794, 0, 0, 0, 5, 799, 125, 0, 0, 1, 794, 0, 0, 0, 1, 799, 0, 0, 0, 1, 800, 0, 0, 0, 3, 78, 39, 801, 0, 1, 99, 0, 0, 0, 3, 102, 51, 807, 0, 5, 804, 86, 0, 0, 3, 102, 51, 806, 0, 1, 803, 0, 0, 0, 1, 809, 0, 0, 0, 1, 805, 0, 0, 0, 1, 808, 0, 0, 0, 1, 101, 0, 0, 0, 1, 807, 0, 0, 0, 3, 14, 7, 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, 61, 0, 0, 3, 162, 81, 818, 0, 1, 103, 0, 0, 0, 3, 162, 81, 824, 0, 5, 821, 87, 0, 0, 3, 162, 81, 823, 0, 1, 820, 0, 0, 0, 1, 826, 0, 0, 0, 1, 822, 0, 0, 0, 1, 825, 0, 0, 0, 1, 105, 0, 0, 0, 1, 824, 0, 0, 0, 3, 108, 54, 835, 0, 3, 110, 55, 835, 0, 5, 835, 75, 0, 0, 5, 835, 76, 0, 0, 5, 835, 74, 0, 0, 5, 835, 78, 0, 0, 5, 835, 77, 0, 0, 1, 827, 0, 0, 0, 1, 828, 0, 0, 0, 1, 829, 0, 0, 0, 1, 830, 0, 0, 0, 1, 831, 0, 0, 0, 1, 832, 0, 0, 0, 1, 833, 0, 0, 0, 1, 107, 0, 0, 0, 7, 837, 1, 0, 0, 1, 109, 0, 0, 0, 7, 839, 2, 0, 0, 1, 111, 0, 0, 0, 5, 841, 124, 0, 0, 3, 104, 52, 842, 0, 1, 844, 0, 0, 0, 3, 114, 57, 845, 0, 1, 843, 0, 0, 0, 1, 845, 0, 0, 0, 1, 113, 0, 0, 0, 5, 855, 79, 0, 0, 3, 116, 58, 852, 0, 5, 849, 86, 0, 0, 3, 116, 58, 851, 0, 1, 848, 0, 0, 0, 1, 854, 0, 0, 0, 1, 850, 0, 0, 0, 1, 853, 0, 0, 0, 1, 856, 0, 0, 0, 1, 852, 0, 0, 0, 1, 847, 0, 0, 0, 1, 856, 0, 0, 0, 1, 857, 0, 0, 0, 5, 858, 80, 0, 0, 1, 115, 0, 0, 0, 4, 860, 58, 0, 0, 3, 118, 59, 866, 0, 3, 162, 81, 862, 0, 5, 863, 88, 0, 0, 3, 118, 59, 864, 0, 1, 866, 0, 0, 0, 1, 859, 0, 0, 0, 1, 861, 0, 0, 0, 1, 117, 0, 0, 0, 3, 196, 98, 885, 0, 3, 112, 56, 885, 0, 5, 878, 81, 0, 0, 3, 118, 59, 875, 0, 5, 872, 86, 0, 0, 3, 118, 59, 874, 0, 1, 871, 0, 0, 0, 1, 877, 0, 0, 0, 1, 873, 0, 0, 0, 1, 876, 0, 0, 0, 1, 879, 0, 0, 0, 1, 875, 0, 0, 0, 1, 870, 0, 0, 0, 1, 879, 0, 0, 0, 1, 881, 0, 0, 0, 5, 882, 86, 0, 0, 1, 880, 0, 0, 0, 1, 882, 0, 0, 0, 1, 883, 0, 0, 0, 5, 885, 82, 0, 0, 1, 867, 0, 0, 0, 1, 868, 0, 0, 0, 1, 869, 0, 0, 0, 1, 119, 0, 0, 0, 3, 196, 98, 890, 0, 3, 112, 56, 890, 0, 3, 122, 61, 890, 0, 1, 886, 0, 0, 0, 1, 887, 0, 0, 0, 1, 888, 0, 0, 0, 1, 121, 0, 0, 0, 5, 900, 81, 0, 0, 3, 120, 60, 897, 0, 5, 894, 86, 0, 0, 3, 120, 60, 896, 0, 1, 893, 0, 0, 0, 1, 899, 0, 0, 0, 1, 895, 0, 0, 0, 1, 898, 0, 0, 0, 1, 901, 0, 0, 0, 1, 897, 0, 0, 0, 1, 892, 0, 0, 0, 1, 901, 0, 0, 0, 1, 903, 0, 0, 0, 5, 904, 86, 0, 0, 1, 902, 0, 0, 0, 1, 904, 0, 0, 0, 1, 905, 0, 0, 0, 5, 906, 82, 0, 0, 1, 123, 0, 0, 0, 5, 908, 124, 0, 0, 5, 909, 29, 0, 0, 3, 162, 81, 910, 0, 3, 126, 63, 911, 0, 1, 125, 0, 0, 0, 5, 916, 81, 0, 0, 3, 128, 64, 915, 0, 1, 913, 0, 0, 0, 1, 918, 0, 0, 0, 1, 914, 0, 0, 0, 1, 917, 0, 0, 0, 1, 919, 0, 0, 0, 1, 916, 0, 0, 0, 5, 920, 82, 0, 0, 1, 127, 0, 0, 0, 3, 10, 5, 923, 0, 1, 921, 0, 0, 0, 1, 926, 0, 0, 0, 1, 922, 0, 0, 0, 1, 925, 0, 0, 0, 1, 927, 0, 0, 0, 1, 924, 0, 0, 0, 3, 130, 65, 930, 0, 5, 930, 85, 0, 0, 1, 924, 0, 0, 0, 1, 928, 0, 0, 0, 1, 129, 0, 0, 0, 3, 244, 122, 932, 0, 3, 132, 66, 933, 0, 5, 934, 85, 0, 0, 1, 956, 0, 0, 0, 3, 16, 8, 937, 0, 5, 938, 85, 0, 0, 1, 936, 0, 0, 0, 1, 938, 0, 0, 0, 1, 956, 0, 0, 0, 3, 32, 16, 941, 0, 5, 942, 85, 0, 0, 1, 940, 0, 0, 0, 1, 942, 0, 0, 0, 1, 956, 0, 0, 0, 3, 24, 12, 945, 0, 5, 946, 85, 0, 0, 1, 944, 0, 0, 0, 1, 946, 0, 0, 0, 1, 956, 0, 0, 0, 3, 124, 62, 949, 0, 5, 950, 85, 0, 0, 1, 948, 0, 0, 0, 1, 950, 0, 0, 0, 1, 956, 0, 0, 0, 3, 146, 73, 953, 0, 5, 954, 85, 0, 0, 1, 952, 0, 0, 0, 1, 954, 0, 0, 0, 1, 956, 0, 0, 0, 1, 931, 0, 0, 0, 1, 935, 0, 0, 0, 1, 939, 0, 0, 0, 1, 943, 0, 0, 0, 1, 947, 0, 0, 0, 1, 951, 0, 0, 0, 1, 131, 0, 0, 0, 3, 134, 67, 960, 0, 3, 136, 68, 960, 0, 1, 957, 0, 0, 0, 1, 958, 0, 0, 0, 1, 133, 0, 0, 0, 3, 162, 81, 962, 0, 5, 963, 79, 0, 0, 5, 965, 80, 0, 0, 3, 138, 69, 966, 0, 1, 964, 0, 0, 0, 1, 966, 0, 0, 0, 1, 135, 0, 0, 0, 3, 74, 37, 968, 0, 1, 137, 0, 0, 0, 5, 970, 12, 0, 0, 3, 120, 60, 971, 0, 1, 139, 0, 0, 0, 3, 112, 56, 974, 0, 1, 972, 0, 0, 0, 1, 977, 0, 0, 0, 1, 973, 0, 0, 0, 1, 976, 0, 0, 0, 1, 979, 0, 0, 0, 1, 975, 0, 0, 0, 5, 980, 35, 0, 0, 1, 978, 0, 0, 0, 1, 980, 0, 0, 0, 1, 981, 0, 0, 0, 5, 982, 31, 0, 0, 3, 104, 52, 983, 0, 5, 987, 81, 0, 0, 3, 142, 71, 986, 0, 1, 984, 0, 0, 0, 1, 989, 0, 0, 0, 1, 985, 0, 0, 0, 1, 988, 0, 0, 0, 1, 990, 0, 0, 0, 1, 987, 0, 0, 0, 5, 991, 82, 0, 0, 1, 141, 0, 0, 0, 5, 996, 44, 0, 0, 3, 144, 72, 995, 0, 1, 993, 0, 0, 0, 1, 998, 0, 0, 0, 1, 994, 0, 0, 0, 1, 997, 0, 0, 0, 1, 999, 0, 0, 0, 1, 996, 0, 0, 0, 3, 104, 52, 1000, 0, 5, 1001, 85, 0, 0, 1, 1050, 0, 0, 0, 5, 1003, 17, 0, 0, 3, 104, 52, 1013, 0, 5, 1005, 56, 0, 0, 3, 104, 52, 1010, 0, 5, 1007, 86, 0, 0, 3, 104, 52, 1009, 0, 1, 1006, 0, 0, 0, 1, 1012, 0, 0, 0, 1, 1008, 0, 0, 0, 1, 1011, 0, 0, 0, 1, 1014, 0, 0, 0, 1, 1010, 0, 0, 0, 1, 1004, 0, 0, 0, 1, 1014, 0, 0, 0, 1, 1015, 0, 0, 0, 5, 1016, 85, 0, 0, 1, 1050, 0, 0, 0, 5, 1018, 36, 0, 0, 3, 104, 52, 1028, 0, 5, 1020, 56, 0, 0, 3, 104, 52, 1025, 0, 5, 1022, 86, 0, 0, 3, 104, 52, 1024, 0, 1, 1021, 0, 0, 0, 1, 1027, 0, 0, 0, 1, 1023, 0, 0, 0, 1, 1026, 0, 0, 0, 1, 1029, 0, 0, 0, 1, 1025, 0, 0, 0, 1, 1019, 0, 0, 0, 1, 1029, 0, 0, 0, 1, 1030, 0, 0, 0, 5, 1031, 85, 0, 0, 1, 1050, 0, 0, 0, 5, 1033, 60, 0, 0, 3, 104, 52, 1034, 0, 5, 1035, 85, 0, 0, 1, 1050, 0, 0, 0, 5, 1037, 41, 0, 0, 3, 104, 52, 1038, 0, 5, 1039, 66, 0, 0, 3, 104, 52, 1044, 0, 5, 1041, 86, 0, 0, 3, 104, 52, 1043, 0, 1, 1040, 0, 0, 0, 1, 1046, 0, 0, 0, 1, 1042, 0, 0, 0, 1, 1045, 0, 0, 0, 1, 1047, 0, 0, 0, 1, 1044, 0, 0, 0, 5, 1048, 85, 0, 0, 1, 1050, 0, 0, 0, 1, 992, 0, 0, 0, 1, 1002, 0, 0, 0, 1, 1017, 0, 0, 0, 1, 1032, 0, 0, 0, 1, 1036, 0, 0, 0, 1, 143, 0, 0, 0, 7, 1052, 3, 0, 0, 1, 145, 0, 0, 0, 5, 1054, 43, 0, 0, 3, 162, 81, 1056, 0, 3, 18, 9, 1057, 0, 1, 1055, 0, 0, 0, 1, 1057, 0, 0, 0, 1, 1058, 0, 0, 0, 3, 148, 74, 1061, 0, 5, 1060, 25, 0, 0, 3, 242, 121, 1062, 0, 1, 1059, 0, 0, 0, 1, 1062, 0, 0, 0, 1, 1063, 0, 0, 0, 3, 154, 77, 1064, 0, 1, 147, 0, 0, 0, 5, 1067, 79, 0, 0, 3, 150, 75, 1068, 0, 1, 1066, 0, 0, 0, 1, 1068, 0, 0, 0, 1, 1069, 0, 0, 0, 5, 1070, 80, 0, 0, 1, 149, 0, 0, 0, 3, 152, 76, 1076, 0, 5, 1073, 86, 0, 0, 3, 152, 76, 1075, 0, 1, 1072, 0, 0, 0, 1, 1078, 0, 0, 0, 1, 1074, 0, 0, 0, 1, 1077, 0, 0, 0, 1, 1079, 0, 0, 0, 1, 1076, 0, 0, 0, 4, 1080, 75, 1, 0, 1, 151, 0, 0, 0, 3, 112, 56, 1083, 0, 1, 1081, 0, 0, 0, 1, 1086, 0, 0, 0, 1, 1082, 0, 0, 0, 1, 1085, 0, 0, 0, 1, 1087, 0, 0, 0, 1, 1084, 0, 0, 0, 3, 244, 122, 1095, 0, 3, 112, 56, 1090, 0, 1, 1088, 0, 0, 0, 1, 1093, 0, 0, 0, 1, 1089, 0, 0, 0, 1, 1092, 0, 0, 0, 1, 1094, 0, 0, 0, 1, 1091, 0, 0, 0, 5, 1096, 125, 0, 0, 1, 1091, 0, 0, 0, 1, 1096, 0, 0, 0, 1, 1097, 0, 0, 0, 3, 162, 81, 1098, 0, 1, 153, 0, 0, 0, 5, 1104, 81, 0, 0, 3, 38, 19, 1103, 0, 3, 54, 27, 1103, 0, 1, 1100, 0, 0, 0, 1, 1101, 0, 0, 0, 1, 1106, 0, 0, 0, 1, 1102, 0, 0, 0, 1, 1105, 0, 0, 0, 1, 1107, 0, 0, 0, 1, 1104, 0, 0, 0, 5, 1108, 82, 0, 0, 1, 155, 0, 0, 0, 5, 1113, 81, 0, 0, 3, 158, 79, 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, 1117, 82, 0, 0, 1, 157, 0, 0, 0, 3, 160, 80, 1119, 0, 5, 1120, 85, 0, 0, 1, 1124, 0, 0, 0, 3, 166, 83, 1124, 0, 3, 168, 84, 1124, 0, 1, 1118, 0, 0, 0, 1, 1121, 0, 0, 0, 1, 1122, 0, 0, 0, 1, 159, 0, 0, 0, 3, 14, 7, 1127, 0, 1, 1125, 0, 0, 0, 1, 1130, 0, 0, 0, 1, 1126, 0, 0, 0, 1, 1129, 0, 0, 0, 1, 1139, 0, 0, 0, 1, 1128, 0, 0, 0, 5, 1132, 61, 0, 0, 3, 162, 81, 1133, 0, 5, 1134, 88, 0, 0, 3, 196, 98, 1135, 0, 1, 1140, 0, 0, 0, 3, 244, 122, 1137, 0, 3, 74, 37, 1138, 0, 1, 1140, 0, 0, 0, 1, 1131, 0, 0, 0, 1, 1136, 0, 0, 0, 1, 161, 0, 0, 0, 7, 1142, 4, 0, 0, 1, 163, 0, 0, 0, 7, 1144, 5, 0, 0, 1, 165, 0, 0, 0, 3, 12, 6, 1147, 0, 1, 1145, 0, 0, 0, 1, 1150, 0, 0, 0, 1, 1146, 0, 0, 0, 1, 1149, 0, 0, 0, 1, 1155, 0, 0, 0, 1, 1148, 0, 0, 0, 3, 16, 8, 1156, 0, 3, 32, 16, 1156, 0, 3, 146, 73, 1156, 0, 3, 24, 12, 1156, 0, 1, 1151, 0, 0, 0, 1, 1152, 0, 0, 0, 1, 1153, 0, 0, 0, 1, 1154, 0, 0, 0, 1, 167, 0, 0, 0, 3, 156, 78, 1281, 0, 5, 1159, 2, 0, 0, 3, 196, 98, 1162, 0, 5, 1161, 94, 0, 0, 3, 196, 98, 1163, 0, 1, 1160, 0, 0, 0, 1, 1163, 0, 0, 0, 1, 1164, 0, 0, 0, 5, 1165, 85, 0, 0, 1, 1281, 0, 0, 0, 5, 1167, 24, 0, 0, 5, 1168, 79, 0, 0, 3, 196, 98, 1169, 0, 5, 1170, 80, 0, 0, 3, 168, 84, 1173, 0, 5, 1172, 15, 0, 0, 3, 168, 84, 1174, 0, 1, 1171, 0, 0, 0, 1, 1174, 0, 0, 0, 1, 1281, 0, 0, 0, 5, 1176, 22, 0, 0, 5, 1177, 79, 0, 0, 3, 186, 93, 1178, 0, 5, 1179, 80, 0, 0, 3, 168, 84, 1180, 0, 1, 1281, 0, 0, 0, 5, 1182, 65, 0, 0, 5, 1183, 79, 0, 0, 3, 196, 98, 1184, 0, 5, 1185, 80, 0, 0, 3, 168, 84, 1186, 0, 1, 1281, 0, 0, 0, 5, 1188, 13, 0, 0, 3, 168, 84, 1189, 0, 5, 1190, 65, 0, 0, 5, 1191, 79, 0, 0, 3, 196, 98, 1192, 0, 5, 1193, 80, 0, 0, 5, 1194, 85, 0, 0, 1, 1281, 0, 0, 0, 5, 1196, 59, 0, 0, 3, 156, 78, 1206, 0, 3, 170, 85, 1199, 0, 1, 1197, 0, 0, 0, 1, 1200, 0, 0, 0, 1, 1198, 0, 0, 0, 1, 1201, 0, 0, 0, 1, 1203, 0, 0, 0, 3, 174, 87, 1204, 0, 1, 1202, 0, 0, 0, 1, 1204, 0, 0, 0, 1, 1207, 0, 0, 0, 3, 174, 87, 1207, 0, 1, 1198, 0, 0, 0, 1, 1205, 0, 0, 0, 1, 1281, 0, 0, 0, 5, 1209, 59, 0, 0, 3, 176, 88, 1210, 0, 3, 156, 78, 1214, 0, 3, 170, 85, 1213, 0, 1, 1211, 0, 0, 0, 1, 1216, 0, 0, 0, 1, 1212, 0, 0, 0, 1, 1215, 0, 0, 0, 1, 1218, 0, 0, 0, 1, 1214, 0, 0, 0, 3, 174, 87, 1219, 0, 1, 1217, 0, 0, 0, 1, 1219, 0, 0, 0, 1, 1281, 0, 0, 0, 5, 1221, 51, 0, 0, 5, 1222, 79, 0, 0, 3, 196, 98, 1223, 0, 5, 1224, 80, 0, 0, 5, 1228, 81, 0, 0, 3, 182, 91, 1227, 0, 1, 1225, 0, 0, 0, 1, 1230, 0, 0, 0, 1, 1226, 0, 0, 0, 1, 1229, 0, 0, 0, 1, 1234, 0, 0, 0, 1, 1228, 0, 0, 0, 3, 184, 92, 1233, 0, 1, 1231, 0, 0, 0, 1, 1236, 0, 0, 0, 1, 1232, 0, 0, 0, 1, 1235, 0, 0, 0, 1, 1237, 0, 0, 0, 1, 1234, 0, 0, 0, 5, 1238, 82, 0, 0, 1, 1281, 0, 0, 0, 5, 1240, 52, 0, 0, 5, 1241, 79, 0, 0, 3, 196, 98, 1242, 0, 5, 1243, 80, 0, 0, 3, 156, 78, 1244, 0, 1, 1281, 0, 0, 0, 5, 1247, 45, 0, 0, 3, 196, 98, 1248, 0, 1, 1246, 0, 0, 0, 1, 1248, 0, 0, 0, 1, 1249, 0, 0, 0, 5, 1281, 85, 0, 0, 5, 1251, 54, 0, 0, 3, 196, 98, 1252, 0, 5, 1253, 85, 0, 0, 1, 1281, 0, 0, 0, 5, 1256, 4, 0, 0, 3, 162, 81, 1257, 0, 1, 1255, 0, 0, 0, 1, 1257, 0, 0, 0, 1, 1258, 0, 0, 0, 5, 1281, 85, 0, 0, 5, 1261, 11, 0, 0, 3, 162, 81, 1262, 0, 1, 1260, 0, 0, 0, 1, 1262, 0, 0, 0, 1, 1263, 0, 0, 0, 5, 1281, 85, 0, 0, 5, 1265, 67, 0, 0, 3, 196, 98, 1266, 0, 5, 1267, 85, 0, 0, 1, 1281, 0, 0, 0, 5, 1281, 85, 0, 0, 3, 196, 98, 1270, 0, 5, 1271, 85, 0, 0, 1, 1281, 0, 0, 0, 3, 212, 106, 1274, 0, 5, 1275, 85, 0, 0, 1, 1273, 0, 0, 0, 1, 1275, 0, 0, 0, 1, 1281, 0, 0, 0, 3, 162, 81, 1277, 0, 5, 1278, 94, 0, 0, 3, 168, 84, 1279, 0, 1, 1281, 0, 0, 0, 1, 1157, 0, 0, 0, 1, 1158, 0, 0, 0, 1, 1166, 0, 0, 0, 1, 1175, 0, 0, 0, 1, 1181, 0, 0, 0, 1, 1187, 0, 0, 0, 1, 1195, 0, 0, 0, 1, 1208, 0, 0, 0, 1, 1220, 0, 0, 0, 1, 1239, 0, 0, 0, 1, 1245, 0, 0, 0, 1, 1250, 0, 0, 0, 1, 1254, 0, 0, 0, 1, 1259, 0, 0, 0, 1, 1264, 0, 0, 0, 1, 1268, 0, 0, 0, 1, 1269, 0, 0, 0, 1, 1272, 0, 0, 0, 1, 1276, 0, 0, 0, 1, 169, 0, 0, 0, 5, 1283, 7, 0, 0, 5, 1287, 79, 0, 0, 3, 14, 7, 1286, 0, 1, 1284, 0, 0, 0, 1, 1289, 0, 0, 0, 1, 1285, 0, 0, 0, 1, 1288, 0, 0, 0, 1, 1290, 0, 0, 0, 1, 1287, 0, 0, 0, 3, 172, 86, 1291, 0, 3, 162, 81, 1292, 0, 5, 1293, 80, 0, 0, 3, 156, 78, 1294, 0, 1, 171, 0, 0, 0, 3, 104, 52, 1300, 0, 5, 1297, 108, 0, 0, 3, 104, 52, 1299, 0, 1, 1296, 0, 0, 0, 1, 1302, 0, 0, 0, 1, 1298, 0, 0, 0, 1, 1301, 0, 0, 0, 1, 173, 0, 0, 0, 1, 1300, 0, 0, 0, 5, 1304, 20, 0, 0, 3, 156, 78, 1305, 0, 1, 175, 0, 0, 0, 5, 1307, 79, 0, 0, 3, 178, 89, 1309, 0, 5, 1310, 85, 0, 0, 1, 1308, 0, 0, 0, 1, 1310, 0, 0, 0, 1, 1311, 0, 0, 0, 5, 1312, 80, 0, 0, 1, 177, 0, 0, 0, 3, 180, 90, 1318, 0, 5, 1315, 85, 0, 0, 3, 180, 90, 1317, 0, 1, 1314, 0, 0, 0, 1, 1320, 0, 0, 0, 1, 1316, 0, 0, 0, 1, 1319, 0, 0, 0, 1, 179, 0, 0, 0, 1, 1318, 0, 0, 0, 3, 14, 7, 1323, 0, 1, 1321, 0, 0, 0, 1, 1326, 0, 0, 0, 1, 1322, 0, 0, 0, 1, 1325, 0, 0, 0, 1, 1332, 0, 0, 0, 1, 1324, 0, 0, 0, 3, 222, 111, 1328, 0, 3, 78, 39, 1329, 0, 1, 1333, 0, 0, 0, 5, 1331, 61, 0, 0, 3, 162, 81, 1333, 0, 1, 1327, 0, 0, 0, 1, 1330, 0, 0, 0, 1, 1334, 0, 0, 0, 5, 1335, 88, 0, 0, 3, 196, 98, 1336, 0, 1, 1339, 0, 0, 0, 3, 104, 52, 1339, 0, 1, 1324, 0, 0, 0, 1, 1337, 0, 0, 0, 1, 181, 0, 0, 0, 3, 184, 92, 1341, 0, 5, 1342, 94, 0, 0, 1, 1344, 0, 0, 0, 1, 1340, 0, 0, 0, 1, 1345, 0, 0, 0, 1, 1343, 0, 0, 0, 1, 1346, 0, 0, 0, 1, 1348, 0, 0, 0, 3, 158, 79, 1349, 0, 1, 1347, 0, 0, 0, 1, 1350, 0, 0, 0, 1, 1348, 0, 0, 0, 1, 1351, 0, 0, 0, 1, 183, 0, 0, 0, 5, 1358, 6, 0, 0, 3, 196, 98, 1359, 0, 5, 1359, 129, 0, 0, 3, 244, 122, 1356, 0, 3, 162, 81, 1357, 0, 1, 1359, 0, 0, 0, 1, 1353, 0, 0, 0, 1, 1354, 0, 0, 0, 1, 1355, 0, 0, 0, 1, 1362, 0, 0, 0, 5, 1362, 12, 0, 0, 1, 1352, 0, 0, 0, 1, 1360, 0, 0, 0, 1, 185, 0, 0, 0, 3, 190, 95, 1376, 0, 3, 188, 94, 1366, 0, 1, 1364, 0, 0, 0, 1, 1366, 0, 0, 0, 1, 1367, 0, 0, 0, 5, 1369, 85, 0, 0, 3, 196, 98, 1370, 0, 1, 1368, 0, 0, 0, 1, 1370, 0, 0, 0, 1, 1371, 0, 0, 0, 5, 1373, 85, 0, 0, 3, 192, 96, 1374, 0, 1, 1372, 0, 0, 0, 1, 1374, 0, 0, 0, 1, 1376, 0, 0, 0, 1, 1363, 0, 0, 0, 1, 1365, 0, 0, 0, 1, 187, 0, 0, 0, 3, 160, 80, 1380, 0, 3, 192, 96, 1380, 0, 1, 1377, 0, 0, 0, 1, 1378, 0, 0, 0, 1, 189, 0, 0, 0, 3, 14, 7, 1383, 0, 1, 1381, 0, 0, 0, 1, 1386, 0, 0, 0, 1, 1382, 0, 0, 0, 1, 1385, 0, 0, 0, 1, 1389, 0, 0, 0, 1, 1384, 0, 0, 0, 3, 244, 122, 1390, 0, 5, 1390, 61, 0, 0, 1, 1387, 0, 0, 0, 1, 1388, 0, 0, 0, 1, 1391, 0, 0, 0, 3, 78, 39, 1392, 0, 5, 1393, 94, 0, 0, 3, 196, 98, 1394, 0, 1, 191, 0, 0, 0, 3, 196, 98, 1400, 0, 5, 1397, 86, 0, 0, 3, 196, 98, 1399, 0, 1, 1396, 0, 0, 0, 1, 1402, 0, 0, 0, 1, 1398, 0, 0, 0, 1, 1401, 0, 0, 0, 1, 193, 0, 0, 0, 1, 1400, 0, 0, 0, 3, 162, 81, 1407, 0, 5, 1407, 53, 0, 0, 5, 1407, 50, 0, 0, 1, 1403, 0, 0, 0, 1, 1404, 0, 0, 0, 1, 1405, 0, 0, 0, 1, 1408, 0, 0, 0, 3, 254, 127, 1409, 0, 1, 195, 0, 0, 0, 6, 1411, 98, 4294967295, 0, 3, 210, 105, 1454, 0, 3, 194, 97, 1454, 0, 3, 244, 122, 1414, 0, 5, 1420, 123, 0, 0, 3, 248, 124, 1417, 0, 1, 1415, 0, 0, 0, 1, 1417, 0, 0, 0, 1, 1418, 0, 0, 0, 3, 162, 81, 1421, 0, 5, 1421, 33, 0, 0, 1, 1416, 0, 0, 0, 1, 1419, 0, 0, 0, 1, 1454, 0, 0, 0, 3, 84, 42, 1423, 0, 5, 1425, 123, 0, 0, 3, 248, 124, 1426, 0, 1, 1424, 0, 0, 0, 1, 1426, 0, 0, 0, 1, 1427, 0, 0, 0, 5, 1428, 33, 0, 0, 1, 1454, 0, 0, 0, 3, 212, 106, 1454, 0, 7, 1431, 6, 0, 0, 3, 196, 98, 1454, 17, 5, 1436, 79, 0, 0, 3, 112, 56, 1435, 0, 1, 1433, 0, 0, 0, 1, 1438, 0, 0, 0, 1, 1434, 0, 0, 0, 1, 1437, 0, 0, 0, 1, 1439, 0, 0, 0, 1, 1436, 0, 0, 0, 3, 244, 122, 1444, 0, 5, 1441, 107, 0, 0, 3, 244, 122, 1443, 0, 1, 1440, 0, 0, 0, 1, 1446, 0, 0, 0, 1, 1442, 0, 0, 0, 1, 1445, 0, 0, 0, 1, 1447, 0, 0, 0, 1, 1444, 0, 0, 0, 5, 1448, 80, 0, 0, 3, 196, 98, 1449, 16, 1, 1454, 0, 0, 0, 5, 1451, 33, 0, 0, 3, 224, 112, 1454, 0, 3, 204, 102, 1454, 0, 1, 1410, 0, 0, 0, 1, 1412, 0, 0, 0, 1, 1413, 0, 0, 0, 1, 1422, 0, 0, 0, 1, 1429, 0, 0, 0, 1, 1430, 0, 0, 0, 1, 1432, 0, 0, 0, 1, 1450, 0, 0, 0, 1, 1452, 0, 0, 0, 1, 1538, 0, 0, 0, 10, 1456, 25, 0, 0, 5, 1457, 83, 0, 0, 3, 196, 98, 1458, 0, 5, 1459, 84, 0, 0, 1, 1537, 0, 0, 0, 10, 1461, 24, 0, 0, 5, 1473, 87, 0, 0, 3, 162, 81, 1474, 0, 3, 194, 97, 1474, 0, 5, 1474, 53, 0, 0, 5, 1467, 33, 0, 0, 3, 240, 120, 1468, 0, 1, 1466, 0, 0, 0, 1, 1468, 0, 0, 0, 1, 1469, 0, 0, 0, 3, 228, 114, 1474, 0, 5, 1471, 50, 0, 0, 3, 250, 125, 1474, 0, 3, 234, 117, 1474, 0, 1, 1462, 0, 0, 0, 1, 1463, 0, 0, 0, 1, 1464, 0, 0, 0, 1, 1465, 0, 0, 0, 1, 1470, 0, 0, 0, 1, 1472, 0, 0, 0, 1, 1537, 0, 0, 0, 10, 1476, 22, 0, 0, 5, 1478, 123, 0, 0, 3, 248, 124, 1479, 0, 1, 1477, 0, 0, 0, 1, 1479, 0, 0, 0, 1, 1480, 0, 0, 0, 3, 162, 81, 1537, 0, 10, 1482, 18, 0, 0, 7, 1537, 7, 0, 0, 10, 1484, 14, 0, 0, 7, 1485, 8, 0, 0, 3, 196, 98, 1537, 15, 10, 1487, 13, 0, 0, 7, 1488, 9, 0, 0, 3, 196, 98, 1537, 14, 10, 1497, 12, 0, 0, 5, 1491, 90, 0, 0, 5, 1498, 90, 0, 0, 5, 1493, 89, 0, 0, 5, 1494, 89, 0, 0, 5, 1498, 89, 0, 0, 5, 1496, 89, 0, 0, 5, 1498, 89, 0, 0, 1, 1490, 0, 0, 0, 1, 1492, 0, 0, 0, 1, 1495, 0, 0, 0, 1, 1499, 0, 0, 0, 3, 196, 98, 1537, 13, 10, 1501, 11, 0, 0, 7, 1502, 10, 0, 0, 3, 196, 98, 1537, 12, 10, 1504, 10, 0, 0, 5, 1507, 27, 0, 0, 3, 244, 122, 1508, 0, 3, 198, 99, 1508, 0, 1, 1505, 0, 0, 0, 1, 1506, 0, 0, 0, 1, 1537, 0, 0, 0, 10, 1510, 9, 0, 0, 7, 1511, 11, 0, 0, 3, 196, 98, 1537, 10, 10, 1513, 8, 0, 0, 5, 1514, 107, 0, 0, 3, 196, 98, 1537, 9, 10, 1516, 7, 0, 0, 5, 1517, 109, 0, 0, 3, 196, 98, 1537, 8, 10, 1519, 6, 0, 0, 5, 1520, 108, 0, 0, 3, 196, 98, 1537, 7, 10, 1522, 5, 0, 0, 5, 1523, 99, 0, 0, 3, 196, 98, 1537, 6, 10, 1525, 4, 0, 0, 5, 1526, 100, 0, 0, 3, 196, 98, 1537, 5, 10, 1528, 3, 0, 0, 5, 1529, 93, 0, 0, 3, 196, 98, 1530, 0, 5, 1531, 94, 0, 0, 3, 196, 98, 1532, 3, 1, 1537, 0, 0, 0, 10, 1534, 2, 0, 0, 7, 1535, 12, 0, 0, 3, 196, 98, 1537, 2, 1, 1455, 0, 0, 0, 1, 1460, 0, 0, 0, 1, 1475, 0, 0, 0, 1, 1481, 0, 0, 0, 1, 1483, 0, 0, 0, 1, 1486, 0, 0, 0, 1, 1489, 0, 0, 0, 1, 1500, 0, 0, 0, 1, 1503, 0, 0, 0, 1, 1509, 0, 0, 0, 1, 1512, 0, 0, 0, 1, 1515, 0, 0, 0, 1, 1518, 0, 0, 0, 1, 1521, 0, 0, 0, 1, 1524, 0, 0, 0, 1, 1527, 0, 0, 0, 1, 1533, 0, 0, 0, 1, 1540, 0, 0, 0, 1, 1536, 0, 0, 0, 1, 1539, 0, 0, 0, 1, 197, 0, 0, 0, 1, 1538, 0, 0, 0, 3, 14, 7, 1543, 0, 1, 1541, 0, 0, 0, 1, 1546, 0, 0, 0, 1, 1542, 0, 0, 0, 1, 1545, 0, 0, 0, 1, 1547, 0, 0, 0, 1, 1544, 0, 0, 0, 3, 244, 122, 1551, 0, 3, 112, 56, 1550, 0, 1, 1548, 0, 0, 0, 1, 1553, 0, 0, 0, 1, 1549, 0, 0, 0, 1, 1552, 0, 0, 0, 1, 1554, 0, 0, 0, 1, 1551, 0, 0, 0, 3, 74, 37, 1555, 0, 1, 1564, 0, 0, 0, 3, 244, 122, 1557, 0, 5, 1559, 79, 0, 0, 3, 200, 100, 1560, 0, 1, 1558, 0, 0, 0, 1, 1560, 0, 0, 0, 1, 1561, 0, 0, 0, 5, 1562, 80, 0, 0, 1, 1564, 0, 0, 0, 1, 1544, 0, 0, 0, 1, 1556, 0, 0, 0, 1, 199, 0, 0, 0, 3, 202, 101, 1570, 0, 5, 1567, 86, 0, 0, 3, 202, 101, 1569, 0, 1, 1566, 0, 0, 0, 1, 1572, 0, 0, 0, 1, 1568, 0, 0, 0, 1, 1571, 0, 0, 0, 1, 201, 0, 0, 0, 1, 1570, 0, 0, 0, 3, 198, 99, 1574, 0, 1, 203, 0, 0, 0, 3, 206, 103, 1576, 0, 5, 1577, 122, 0, 0, 3, 208, 104, 1578, 0, 1, 205, 0, 0, 0, 3, 162, 81, 1602, 0, 5, 1582, 79, 0, 0, 3, 96, 48, 1583, 0, 1, 1581, 0, 0, 0, 1, 1583, 0, 0, 0, 1, 1584, 0, 0, 0, 5, 1602, 80, 0, 0, 5, 1586, 79, 0, 0, 3, 162, 81, 1591, 0, 5, 1588, 86, 0, 0, 3, 162, 81, 1590, 0, 1, 1587, 0, 0, 0, 1, 1593, 0, 0, 0, 1, 1589, 0, 0, 0, 1, 1592, 0, 0, 0, 1, 1594, 0, 0, 0, 1, 1591, 0, 0, 0, 5, 1595, 80, 0, 0, 1, 1602, 0, 0, 0, 5, 1598, 79, 0, 0, 3, 100, 50, 1599, 0, 1, 1597, 0, 0, 0, 1, 1599, 0, 0, 0, 1, 1600, 0, 0, 0, 5, 1602, 80, 0, 0, 1, 1579, 0, 0, 0, 1, 1580, 0, 0, 0, 1, 1585, 0, 0, 0, 1, 1596, 0, 0, 0, 1, 207, 0, 0, 0, 3, 196, 98, 1606, 0, 3, 156, 78, 1606, 0, 1, 1603, 0, 0, 0, 1, 1604, 0, 0, 0, 1, 209, 0, 0, 0, 5, 1608, 79, 0, 0, 3, 196, 98, 1609, 0, 5, 1610, 80, 0, 0, 1, 1626, 0, 0, 0, 5, 1626, 53, 0, 0, 5, 1626, 50, 0, 0, 3, 106, 53, 1626, 0, 3, 162, 81, 1626, 0, 3, 46, 23, 1616, 0, 5, 1617, 87, 0, 0, 5, 1618, 9, 0, 0, 1, 1626, 0, 0, 0, 3, 240, 120, 1623, 0, 3, 252, 126, 1624, 0, 5, 1622, 53, 0, 0, 3, 254, 127, 1624, 0, 1, 1620, 0, 0, 0, 1, 1621, 0, 0, 0, 1, 1626, 0, 0, 0, 1, 1607, 0, 0, 0, 1, 1611, 0, 0, 0, 1, 1612, 0, 0, 0, 1, 1613, 0, 0, 0, 1, 1614, 0, 0, 0, 1, 1615, 0, 0, 0, 1, 1619, 0, 0, 0, 1, 211, 0, 0, 0, 5, 1628, 51, 0, 0, 5, 1629, 79, 0, 0, 3, 196, 98, 1630, 0, 5, 1631, 80, 0, 0, 5, 1635, 81, 0, 0, 3, 214, 107, 1634, 0, 1, 1632, 0, 0, 0, 1, 1637, 0, 0, 0, 1, 1633, 0, 0, 0, 1, 1636, 0, 0, 0, 1, 1638, 0, 0, 0, 1, 1635, 0, 0, 0, 5, 1639, 82, 0, 0, 1, 213, 0, 0, 0, 5, 1658, 6, 0, 0, 3, 192, 96, 1659, 0, 5, 1645, 78, 0, 0, 5, 1644, 86, 0, 0, 5, 1646, 12, 0, 0, 1, 1643, 0, 0, 0, 1, 1646, 0, 0, 0, 1, 1659, 0, 0, 0, 3, 218, 109, 1652, 0, 5, 1649, 86, 0, 0, 3, 218, 109, 1651, 0, 1, 1648, 0, 0, 0, 1, 1654, 0, 0, 0, 1, 1650, 0, 0, 0, 1, 1653, 0, 0, 0, 1, 1656, 0, 0, 0, 1, 1652, 0, 0, 0, 3, 216, 108, 1657, 0, 1, 1655, 0, 0, 0, 1, 1657, 0, 0, 0, 1, 1659, 0, 0, 0, 1, 1641, 0, 0, 0, 1, 1642, 0, 0, 0, 1, 1647, 0, 0, 0, 1, 1660, 0, 0, 0, 7, 1661, 13, 0, 0, 3, 220, 110, 1666, 0, 5, 1663, 12, 0, 0, 7, 1664, 13, 0, 0, 3, 220, 110, 1666, 0, 1, 1640, 0, 0, 0, 1, 1662, 0, 0, 0, 1, 215, 0, 0, 0, 5, 1668, 64, 0, 0, 3, 196, 98, 1669, 0, 1, 217, 0, 0, 0, 3, 198, 99, 1671, 0, 1, 219, 0, 0, 0, 3, 156, 78, 1680, 0, 3, 158, 79, 1675, 0, 1, 1673, 0, 0, 0, 1, 1678, 0, 0, 0, 1, 1674, 0, 0, 0, 1, 1677, 0, 0, 0, 1, 1680, 0, 0, 0, 1, 1676, 0, 0, 0, 1, 1672, 0, 0, 0, 1, 1676, 0, 0, 0, 1, 221, 0, 0, 0, 3, 84, 42, 1682, 0, 1, 223, 0, 0, 0, 3, 240, 120, 1685, 0, 1, 1683, 0, 0, 0, 1, 1685, 0, 0, 0, 1, 1686, 0, 0, 0, 3, 226, 113, 1687, 0, 3, 232, 116, 1688, 0, 1, 1693, 0, 0, 0, 3, 226, 113, 1690, 0, 3, 230, 115, 1691, 0, 1, 1693, 0, 0, 0, 1, 1684, 0, 0, 0, 1, 1689, 0, 0, 0, 1, 225, 0, 0, 0, 3, 162, 81, 1696, 0, 3, 236, 118, 1697, 0, 1, 1695, 0, 0, 0, 1, 1697, 0, 0, 0, 1, 1705, 0, 0, 0, 5, 1699, 87, 0, 0, 3, 162, 81, 1701, 0, 3, 236, 118, 1702, 0, 1, 1700, 0, 0, 0, 1, 1702, 0, 0, 0, 1, 1704, 0, 0, 0, 1, 1698, 0, 0, 0, 1, 1707, 0, 0, 0, 1, 1703, 0, 0, 0, 1, 1706, 0, 0, 0, 1, 1710, 0, 0, 0, 1, 1705, 0, 0, 0, 3, 246, 123, 1710, 0, 1, 1694, 0, 0, 0, 1, 1708, 0, 0, 0, 1, 227, 0, 0, 0, 3, 162, 81, 1713, 0, 3, 238, 119, 1714, 0, 1, 1712, 0, 0, 0, 1, 1714, 0, 0, 0, 1, 1715, 0, 0, 0, 3, 232, 116, 1716, 0, 1, 229, 0, 0, 0, 5, 1718, 83, 0, 0, 5, 1720, 84, 0, 0, 1, 1717, 0, 0, 0, 1, 1721, 0, 0, 0, 1, 1719, 0, 0, 0, 1, 1722, 0, 0, 0, 1, 1723, 0, 0, 0, 3, 82, 41, 1740, 0, 5, 1725, 83, 0, 0, 3, 196, 98, 1726, 0, 5, 1727, 84, 0, 0, 1, 1729, 0, 0, 0, 1, 1724, 0, 0, 0, 1, 1730, 0, 0, 0, 1, 1728, 0, 0, 0, 1, 1731, 0, 0, 0, 1, 1736, 0, 0, 0, 5, 1733, 83, 0, 0, 5, 1735, 84, 0, 0, 1, 1732, 0, 0, 0, 1, 1738, 0, 0, 0, 1, 1734, 0, 0, 0, 1, 1737, 0, 0, 0, 1, 1740, 0, 0, 0, 1, 1736, 0, 0, 0, 1, 1719, 0, 0, 0, 1, 1728, 0, 0, 0, 1, 231, 0, 0, 0, 3, 254, 127, 1743, 0, 3, 34, 17, 1744, 0, 1, 1742, 0, 0, 0, 1, 1744, 0, 0, 0, 1, 233, 0, 0, 0, 3, 240, 120, 1746, 0, 3, 252, 126, 1747, 0, 1, 235, 0, 0, 0, 5, 1749, 90, 0, 0, 5, 1752, 89, 0, 0, 3, 248, 124, 1752, 0, 1, 1748, 0, 0, 0, 1, 1750, 0, 0, 0, 1, 237, 0, 0, 0, 5, 1754, 90, 0, 0, 5, 1757, 89, 0, 0, 3, 240, 120, 1757, 0, 1, 1753, 0, 0, 0, 1, 1755, 0, 0, 0, 1, 239, 0, 0, 0, 5, 1759, 90, 0, 0, 3, 242, 121, 1760, 0, 5, 1761, 89, 0, 0, 1, 241, 0, 0, 0, 3, 244, 122, 1767, 0, 5, 1764, 86, 0, 0, 3, 244, 122, 1766, 0, 1, 1763, 0, 0, 0, 1, 1769, 0, 0, 0, 1, 1765, 0, 0, 0, 1, 1768, 0, 0, 0, 1, 243, 0, 0, 0, 1, 1767, 0, 0, 0, 3, 112, 56, 1772, 0, 1, 1770, 0, 0, 0, 1, 1775, 0, 0, 0, 1, 1771, 0, 0, 0, 1, 1774, 0, 0, 0, 1, 1778, 0, 0, 0, 1, 1773, 0, 0, 0, 3, 222, 111, 1779, 0, 3, 246, 123, 1779, 0, 1, 1776, 0, 0, 0, 1, 1777, 0, 0, 0, 1, 1790, 0, 0, 0, 3, 112, 56, 1782, 0, 1, 1780, 0, 0, 0, 1, 1785, 0, 0, 0, 1, 1781, 0, 0, 0, 1, 1784, 0, 0, 0, 1, 1786, 0, 0, 0, 1, 1783, 0, 0, 0, 5, 1787, 83, 0, 0, 5, 1789, 84, 0, 0, 1, 1783, 0, 0, 0, 1, 1792, 0, 0, 0, 1, 1788, 0, 0, 0, 1, 1791, 0, 0, 0, 1, 245, 0, 0, 0, 1, 1790, 0, 0, 0, 7, 1794, 14, 0, 0, 1, 247, 0, 0, 0, 5, 1796, 90, 0, 0, 3, 88, 44, 1801, 0, 5, 1798, 86, 0, 0, 3, 88, 44, 1800, 0, 1, 1797, 0, 0, 0, 1, 1803, 0, 0, 0, 1, 1799, 0, 0, 0, 1, 1802, 0, 0, 0, 1, 1804, 0, 0, 0, 1, 1801, 0, 0, 0, 5, 1805, 89, 0, 0, 1, 249, 0, 0, 0, 3, 254, 127, 1816, 0, 5, 1809, 87, 0, 0, 3, 248, 124, 1810, 0, 1, 1808, 0, 0, 0, 1, 1810, 0, 0, 0, 1, 1811, 0, 0, 0, 3, 162, 81, 1813, 0, 3, 254, 127, 1814, 0, 1, 1812, 0, 0, 0, 1, 1814, 0, 0, 0, 1, 1816, 0, 0, 0, 1, 1806, 0, 0, 0, 1, 1807, 0, 0, 0, 1, 251, 0, 0, 0, 5, 1818, 50, 0, 0, 3, 250, 125, 1823, 0, 3, 162, 81, 1820, 0, 3, 254, 127, 1821, 0, 1, 1823, 0, 0, 0, 1, 1817, 0, 0, 0, 1, 1819, 0, 0, 0, 1, 253, 0, 0, 0, 5, 1826, 79, 0, 0, 3, 192, 96, 1827, 0, 1, 1825, 0, 0, 0, 1, 1827, 0, 0, 0, 1, 1828, 0, 0, 0, 5, 1829, 80, 0, 0, 1, 255, 0, 0, 0, 0, 2, 1, 0, 2, 2, 1, 1, 2, 2, 3, 1, 1, 4, 2, 4, 2, 1, 6, 2, 6, 13, 2, 8, 3, 19, 11, 2, 11, 3, 30, 2, 1, 14, 2, 32, 1, 1, 16, 2, 33, 2, 1, 18, 2, 35, 1, 1, 20, 2, 36, 2, 1, 22, 2, 38, 2, 1, 24, 2, 40, 2, 1, 26, 2, 42, 2, 1, 28, 2, 44, 8, 1, 30, 2, 18, 18, 50, 50, 68, 71, 72, 73, 48, 48, 58, 58, 17, 17, 31, 31, 35, 36, 38, 38, 41, 41, 43, 44, 46, 46, 56, 56, 58, 58, 60, 61, 64, 64, 66, 67, 129, 129, 17, 17, 31, 31, 35, 36, 41, 41, 44, 44, 46, 46, 56, 56, 58, 58, 60, 60, 66, 66, 129, 129, 91, 92, 101, 104, 101, 102, 105, 106, 110, 110, 103, 104, 89, 90, 96, 97, 95, 95, 98, 98, 88, 88, 111, 121, 94, 94, 122, 122, 3, 3, 5, 5, 8, 8, 14, 14, 21, 21, 28, 28, 30, 30, 47, 47, 262144, 262144, 0, 0, 0, 0, 240, 0, 0, 0, 768, 0, 0, 67174400, 0, 0, 2147614720, 889215576, 13, 0, 2, 0, 2147614720, 352342552, 4, 0, 2, 0, 0, 0, 402653184, 480, 0, 0, 0, 96, 0, 0, 0, 17920, 0, 0, 0, 384, 0, 0, 100663296, 3, 0, 0, 2147483648, 4, 0, 0, 16777216, 67076096, 0, 0, 1073741824, 67108864, 1344291112, 32768, 0, 0, 257, 261, 263, 268, 270, 277, 282, 290, 299, 304, 311, 319, 326, 338, 342, 347, 351, 355, 359, 369, 377, 385, 389, 396, 403, 407, 410, 413, 422, 428, 433, 436, 442, 448, 452, 456, 464, 473, 480, 486, 490, 502, 511, 516, 522, 526, 538, 545, 558, 563, 573, 581, 591, 600, 611, 616, 625, 635, 640, 649, 655, 662, 667, 675, 679, 681, 690, 693, 697, 701, 707, 712, 716, 724, 731, 737, 739, 746, 752, 758, 761, 771, 781, 787, 794, 798, 807, 813, 824, 834, 844, 852, 855, 865, 875, 878, 881, 884, 889, 897, 900, 903, 916, 924, 929, 937, 941, 945, 949, 953, 955, 959, 965, 975, 979, 987, 996, 1010, 1013, 1025, 1028, 1044, 1049, 1056, 1061, 1067, 1076, 1084, 1091, 1095, 1102, 1104, 1113, 1123, 1128, 1139, 1148, 1155, 1162, 1173, 1200, 1203, 1206, 1214, 1218, 1228, 1234, 1247, 1256, 1261, 1274, 1280, 1287, 1300, 1309, 1318, 1324, 1332, 1338, 1345, 1350, 1358, 1361, 1365, 1369, 1373, 1375, 1379, 1384, 1389, 1400, 1406, 1416, 1420, 1425, 1436, 1444, 1453, 1467, 1473, 1478, 1497, 1507, 1536, 1538, 1544, 1551, 1559, 1563, 1570, 1582, 1591, 1598, 1601, 1605, 1623, 1625, 1635, 1645, 1652, 1656, 1658, 1665, 1676, 1679, 1684, 1692, 1696, 1701, 1705, 1709, 1713, 1721, 1730, 1736, 1739, 1743, 1751, 1756, 1767, 1773, 1778, 1783, 1790, 1801, 1809, 1813, 1815, 1822, 1826, 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, 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];
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 JavaParserParseOutput<R, L>
where
    L: TokenSource,
{
    pub result: R,
    pub parser: JavaParser<L>,
}

impl<L: TokenSource> JavaParserParseOutput<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<JavaValidatedTree, JavaValidationError> {
        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(JavaValidationError::SyntaxErrors { lexer, parser });
        }
        let parsed = self.parser.into_parsed_file(self.result);
        validate_tree_structure(&parsed)?;
        Ok(JavaValidatedTree::__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, JavaParser::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 JavaParser<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 JavaParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<JavaValidatedTree, JavaValidationError>
{
    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 `JavaParser::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 JavaParser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<JavaParserParseOutput<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 JavaParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<antlr4_runtime::ParsedFile, antlr4_runtime::AntlrError>
{
    let JavaParserParseOutput { 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 JavaParser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<JavaValidatedTree, JavaValidationError>
{
    let output = parse_stream_with_parser(input, lexer, entry)
        .map_err(JavaValidationError::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 JavaParser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<JavaParserParseOutput<R, L>, antlr4_runtime::AntlrError>
{
    let lexer = lexer(input);
    let tokens = CommonTokenStream::new(lexer);
    let mut parser = JavaParser::new(tokens);
    let result = entry(&mut parser)?;
    Ok(JavaParserParseOutput { 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()`
/// - `modular_compulation_unit()`
/// - `package_declaration()`
/// - `import_declaration()`
/// - `type_declaration()`
/// - `modifier()`
/// - `class_or_interface_modifier()`
/// - `variable_modifier()`
/// - `class_declaration()`
/// - `type_parameters()`
/// - `type_parameter()`
/// - `type_bound()`
/// - `enum_declaration()`
/// - `enum_constants()`
/// - `enum_constant()`
/// - `enum_body_declarations()`
/// - `interface_declaration()`
/// - `class_body()`
/// - `interface_body()`
/// - `class_body_declaration()`
/// - `member_declaration()`
/// - `method_declaration()`
/// - `method_body()`
/// - `type_type_or_void()`
/// - `generic_method_declaration()`
/// - `generic_constructor_declaration()`
/// - `constructor_declaration()`
/// - `compact_constructor_declaration()`
/// - `field_declaration()`
/// - `interface_body_declaration()`
/// - `interface_member_declaration()`
/// - `const_declaration()`
/// - `constant_declarator()`
/// - `interface_method_declaration()`
/// - `interface_method_modifier()`
/// - `generic_interface_method_declaration()`
/// - `interface_common_body_declaration()`
/// - `variable_declarators()`
/// - `variable_declarator()`
/// - `variable_declarator_id()`
/// - `variable_initializer()`
/// - `array_initializer()`
/// - `class_type()`
/// - `package_name()`
/// - `type_argument()`
/// - `qualified_name_list()`
/// - `formal_parameters()`
/// - `receiver_parameter()`
/// - `formal_parameter_list()`
/// - `formal_parameter()`
/// - `lambda_lvti_list()`
/// - `lambda_lvti_parameter()`
/// - `qualified_name()`
/// - `literal()`
/// - `integer_literal()`
/// - `float_literal()`
/// - `annotation()`
/// - `annotation_field_values()`
/// - `annotation_field_value()`
/// - `annotation_value()`
/// - `element_value()`
/// - `element_value_array_initializer()`
/// - `annotation_type_declaration()`
/// - `annotation_type_body()`
/// - `annotation_type_element_declaration()`
/// - `annotation_type_element_rest()`
/// - `annotation_method_or_constant_rest()`
/// - `annotation_method_rest()`
/// - `annotation_constant_rest()`
/// - `default_value()`
/// - `module_declaration()`
/// - `module_directive()`
/// - `requires_modifier()`
/// - `record_declaration()`
/// - `record_header()`
/// - `record_component_list()`
/// - `record_component()`
/// - `record_body()`
/// - `block()`
/// - `block_statement()`
/// - `local_variable_declaration()`
/// - `identifier()`
/// - `type_identifier()`
/// - `local_type_declaration()`
/// - `statement()`
/// - `catch_clause()`
/// - `catch_type()`
/// - `finally_block()`
/// - `resource_specification()`
/// - `resources()`
/// - `resource()`
/// - `switch_block_statement_group()`
/// - `switch_label()`
/// - `for_control()`
/// - `for_init()`
/// - `enhanced_for_control()`
/// - `expression_list()`
/// - `method_call()`
/// - `expression()`
/// - `pattern()`
/// - `component_pattern_list()`
/// - `component_pattern()`
/// - `lambda_expression()`
/// - `lambda_parameters()`
/// - `lambda_body()`
/// - `primary()`
/// - `switch_expression()`
/// - `switch_labeled_rule()`
/// - `guard()`
/// - `case_pattern()`
/// - `switch_rule_outcome()`
/// - `class_or_interface_type()`
/// - `creator()`
/// - `created_name()`
/// - `inner_creator()`
/// - `array_creator_rest()`
/// - `class_creator_rest()`
/// - `explicit_generic_invocation()`
/// - `type_arguments_or_diamond()`
/// - `non_wildcard_type_arguments_or_diamond()`
/// - `non_wildcard_type_arguments()`
/// - `type_list()`
/// - `type_type()`
/// - `primitive_type()`
/// - `type_arguments()`
/// - `super_suffix()`
/// - `explicit_generic_invocation_suffix()`
/// - `arguments()`
#[derive(Debug)]
pub struct JavaParser<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> JavaParser<L, antlr4_runtime::NoSemanticHooks>
where
    L: TokenSource,
{
    pub fn new(input: CommonTokenStream<L>) -> Self {
        Self::with_hooks(input, antlr4_runtime::NoSemanticHooks)
    }
}

impl<L, H> JavaParser<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: true, 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 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_84_dispatch(precedence, allow_fallback)),
            84 if !self.adaptive_atn_preferred_rules[0] => Some(self.parse_generated_rule_84_adaptive_dispatch(precedence, allow_fallback, None)),
            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 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_98_dispatch(precedence, allow_fallback)),
            98 if !self.adaptive_atn_preferred_rules[1] => Some(self.parse_generated_rule_98_adaptive_dispatch(precedence, allow_fallback, None)),
            99 => Some(self.parse_generated_rule_99_dispatch(precedence, allow_fallback)),
            100 => Some(self.parse_generated_rule_100_dispatch(precedence, allow_fallback)),
            101 => Some(self.parse_generated_rule_101_dispatch(precedence, allow_fallback)),
            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)),
            _ => 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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    -1 | 1 | 9 | 16 | 19 | 29 | 34 | 37 | 39..=40 | 42..=43 | 46 | 48..=49 | 85 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    31 | 35 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 277, !__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(), 277) {
                            __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(5, 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(5, 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(), 277, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        match self.base.sync_decision(atn(), 257, !__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(), 257) {
                            __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(), 257, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(256isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let mut __loop_iter_263 = false;
                        loop {
                            match self.base.sync_decision(atn(), 263, !__ctx.has_matched_child(), __loop_iter_263) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 263) {
                                __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(), 263, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_263 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = match self.base.la(1) {
                                        26 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        85 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => {
                                            match self.base.sync_decision(atn(), 261, !__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) {
                                                26 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                                85 => 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(), 261, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(259isize);
                                            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 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            let __match = self.base.match_token_recovering(85, 262, 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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let mut __loop_iter_270 = false;
                        loop {
                            match self.base.sync_decision(atn(), 270, !__ctx.has_matched_child(), __loop_iter_270) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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 | 9 | 16 | 19 | 29 | 34 | 39..=40 | 42..=43 | 46 | 48..=49 | 85 | 124 => 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(), 270, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_270 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                    let __prediction = match self.base.la(1) {
                                        1 | 9 | 16 | 19 | 29 | 34 | 39..=40 | 42..=43 | 46 | 48..=49 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        85 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        _ => {
                                            match self.base.sync_decision(atn(), 268, !__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 | 9 | 16 | 19 | 29 | 34 | 39..=40 | 42..=43 | 46 | 48..=49 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                                85 => 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(), 268, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(266isize);
                                            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 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            let __match = self.base.match_token_recovering(85, 269, 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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(-1, 278, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(274isize);
                        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);
                        let __match = self.base.match_token_recovering(-1, 276, 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_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 mut __loop_iter_282 = false;
                loop {
                    match self.base.sync_decision(atn(), 282, !__ctx.has_matched_child(), __loop_iter_282) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        26 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        31 | 35 | 124 => 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(), 282, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_282 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(279isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(285isize);
                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);
            }
            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 {
                let mut __loop_iter_290 = false;
                loop {
                    match self.base.sync_decision(atn(), 290, !__ctx.has_matched_child(), __loop_iter_290) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        37 => 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(), 290, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_290 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(287isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(37, 294, 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(294isize);
                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);
                let __match = self.base.match_token_recovering(85, 296, 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 __match = self.base.match_token_recovering(26, 299, 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(), 299, !__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) {
                    48 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 299, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(48, 300, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(301isize);
                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);
                match self.base.sync_decision(atn(), 304, !__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) {
                    87 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => 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(), 304, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(87, 303, 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(105, 305, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(85, 307, 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 __loop_iter_311 = false;
                loop {
                    match self.base.sync_decision(atn(), 311, !__ctx.has_matched_child(), __loop_iter_311) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 311) {
                        __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(10, 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(10, 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(), 311, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_311 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(308isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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) {
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    43 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 319, !__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) {
                            9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            16 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            29 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            124 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            43 => 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(), 319, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(314isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(315isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(316isize);
                        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);
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(317isize);
                        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);
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(318isize);
                        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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    1 | 19 | 34 | 39..=40 | 42 | 46 | 48..=49 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    57 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    63 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 326, !__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 | 19 | 34 | 39..=40 | 42 | 46 | 48..=49 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            32 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            52 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            57 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            63 => 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(), 326, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(321isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(32, 327, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(52, 327, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(57, 327, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(63, 327, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    40 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    39 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    48 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    1 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    19 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    49 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    46 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    34 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 338, !__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) {
                            124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            40 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            39 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            48 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            1 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            19 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            49 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            46 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            34 => antlr4_runtime::ParserAtnPrediction { alt: 10, 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(), 338, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(328isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(42, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(40, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(39, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(48, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __match = self.base.match_token_recovering(1, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __match = self.base.match_token_recovering(19, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    8 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(8);
                        }
                        let __match = self.base.match_token_recovering(49, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    9 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(9);
                        }
                        let __match = self.base.match_token_recovering(46, 339, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    10 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(10);
                        }
                        let __match = self.base.match_token_recovering(34, 339, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    19 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 342, !__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) {
                            19 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            124 => 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(), 342, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(19, 343, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(341isize);
                        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);
                    }
                    _ => 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> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 8, GeneratedRuleError::Fatal; self.parse_generated_rule_8(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_8(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 16isize, 8, 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(9, 345, 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(345isize);
                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);
                match self.base.sync_decision(atn(), 347, !__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) {
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    18 | 25 | 38 | 81 => 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(), 347, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(346isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 351, !__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) {
                    18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    25 | 38 | 81 => 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(), 351, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(18, 350, 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(350isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 355, !__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) {
                    25 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    38 | 81 => 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(), 355, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(25, 354, 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(354isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 359, !__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) {
                    38 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 359, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(38, 358, 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(358isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(361isize);
                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);
            }
            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 __match = self.base.match_token_recovering(90, 364, 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(364isize);
                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);
                let mut __loop_iter_369 = false;
                loop {
                    match self.base.sync_decision(atn(), 369, !__ctx.has_matched_child(), __loop_iter_369) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        89 => 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(), 369, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_369 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 366, 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(366isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(89, 373, 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_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 {
                let mut __loop_iter_377 = false;
                loop {
                    match self.base.sync_decision(atn(), 377, !__ctx.has_matched_child(), __loop_iter_377) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 377, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_377 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(374isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(380isize);
                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);
                match self.base.sync_decision(atn(), 389, !__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) {
                    18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    86 | 89 => 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(), 389, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(18, 385, 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_385 = false;
                        loop {
                            match self.base.sync_decision(atn(), 385, !__ctx.has_matched_child(), __loop_iter_385) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 385) {
                                __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(), 385, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_385 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(382isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(388isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => 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(391isize);
                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);
                let mut __loop_iter_396 = false;
                loop {
                    match self.base.sync_decision(atn(), 396, !__ctx.has_matched_child(), __loop_iter_396) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        107 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        86 | 89 => 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(), 396, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_396 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(107, 393, 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(393isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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(16, 400, 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(400isize);
                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);
                match self.base.sync_decision(atn(), 403, !__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) {
                    25 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 403, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(25, 402, 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(402isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(81, 407, 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(), 407, !__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) {
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 | 85..=86 => 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(), 407, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(406isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 410, !__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) {
                    86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 | 85 => 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(), 410, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(86, 411, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 413, !__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) {
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 => 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(), 413, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(412isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(82, 416, 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 __invoking_marker = self.base.push_invoking_state(417isize);
                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_422 = false;
                loop {
                    match self.base.sync_decision(atn(), 422, !__ctx.has_matched_child(), __loop_iter_422) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 422) {
                        __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(28, 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(28, 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(), 422, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_422 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 419, 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(419isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 {
                let mut __loop_iter_428 = false;
                loop {
                    match self.base.sync_decision(atn(), 428, !__ctx.has_matched_child(), __loop_iter_428) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 428, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_428 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(425isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(431isize);
                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);
                match self.base.sync_decision(atn(), 433, !__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) {
                    79 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81..=82 | 85..=86 => 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(), 433, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(432isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 436, !__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) {
                    81 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 | 85..=86 => 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(), 436, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(435isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __match = self.base.match_token_recovering(85, 442, 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_442 = false;
                loop {
                    match self.base.sync_decision(atn(), 442, !__ctx.has_matched_child(), __loop_iter_442) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 81 | 85 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 442, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_442 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(439isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 __match = self.base.match_token_recovering(29, 446, 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(446isize);
                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);
                match self.base.sync_decision(atn(), 448, !__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) {
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    18 | 38 | 81 => 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(), 448, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(447isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 452, !__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) {
                    18 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    38 | 81 => 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(), 452, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(18, 451, 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(451isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 456, !__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) {
                    38 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 456, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(38, 455, 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(455isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(458isize);
                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);
            }
            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 __match = self.base.match_token_recovering(81, 464, 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_464 = false;
                loop {
                    match self.base.sync_decision(atn(), 464, !__ctx.has_matched_child(), __loop_iter_464) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 81 | 85 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 464, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_464 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(461isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 468, 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_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 __match = self.base.match_token_recovering(81, 473, 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_473 = false;
                loop {
                    match self.base.sync_decision(atn(), 473, !__ctx.has_matched_child(), __loop_iter_473) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 3 | 5 | 8..=9 | 12 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 85 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 473, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_473 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(470isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 477, 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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    85 => 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 },
                    1 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=47 | 49 | 52 | 56..=58 | 60..=64 | 66..=67 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 490, !__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(), 490) {
                            __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(40, 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(40, 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(), 490, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(85, 491, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        match self.base.sync_decision(atn(), 480, !__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) {
                            48 => 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 },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 480, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(48, 481, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __invoking_marker = self.base.push_invoking_state(482isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let mut __loop_iter_486 = false;
                        loop {
                            match self.base.sync_decision(atn(), 486, !__ctx.has_matched_child(), __loop_iter_486) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 486) {
                                __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(39, 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(39, 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(), 486, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_486 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(483isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(489isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 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 },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 9, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    16 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 502, !__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(), 502) {
                            __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(), 502, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(492isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(493isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(494isize);
                        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);
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(495isize);
                        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);
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(496isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __invoking_marker = self.base.push_invoking_state(497isize);
                        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);
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __invoking_marker = self.base.push_invoking_state(498isize);
                        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);
                    }
                    8 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(8);
                        }
                        let __invoking_marker = self.base.push_invoking_state(499isize);
                        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);
                    }
                    9 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(9);
                        }
                        let __invoking_marker = self.base.push_invoking_state(500isize);
                        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);
                    }
                    10 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(10);
                        }
                        let __invoking_marker = self.base.push_invoking_state(501isize);
                        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);
                    }
                    _ => 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(504isize);
                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 __invoking_marker = self.base.push_invoking_state(505isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(506isize);
                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);
                let mut __loop_iter_511 = false;
                loop {
                    match self.base.sync_decision(atn(), 511, !__ctx.has_matched_child(), __loop_iter_511) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        83 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        55 | 81 | 85 => 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(), 511, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_511 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(83, 508, 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(84, 510, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 516, !__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) {
                    55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 | 85 => 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(), 516, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(55, 515, 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(515isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(518isize);
                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_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 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 },
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 522, !__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 },
                            85 => 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(), 522, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(520isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(85, 523, 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_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 {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 526, !__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) {
                            3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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(), 526, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(524isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(62, 527, 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_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 __invoking_marker = self.base.push_invoking_state(528isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(529isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(531isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(532isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(534isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(535isize);
                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);
                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);
                    }
                }
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    55 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 538, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(55, 537, 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(537isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(540isize);
                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);
            }
            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_545 = false;
                loop {
                    match self.base.sync_decision(atn(), 545, !__ctx.has_matched_child(), __loop_iter_545) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 545) {
                        __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(47, 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(47, 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(), 545, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_545 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(542isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(548isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(549isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(551isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(552isize);
                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);
                let __match = self.base.match_token_recovering(85, 554, 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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    1 | 3 | 5 | 8..=9 | 12 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 563, !__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 | 3 | 5 | 8..=9 | 12 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 563, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_558 = false;
                        loop {
                            match self.base.sync_decision(atn(), 558, !__ctx.has_matched_child(), __loop_iter_558) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 558) {
                                __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(48, 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(48, 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(), 558, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_558 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(555isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(561isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(85, 564, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    62 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    16 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 573, !__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(), 573) {
                            __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(50, 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(50, 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(), 573, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(565isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(566isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(567isize);
                        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);
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(568isize);
                        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);
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(569isize);
                        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);
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __invoking_marker = self.base.push_invoking_state(570isize);
                        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);
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __invoking_marker = self.base.push_invoking_state(571isize);
                        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);
                    }
                    8 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(8);
                        }
                        let __invoking_marker = self.base.push_invoking_state(572isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __invoking_marker = self.base.push_invoking_state(575isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(576isize);
                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_581 = false;
                loop {
                    match self.base.sync_decision(atn(), 581, !__ctx.has_matched_child(), __loop_iter_581) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        85 => 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(), 581, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_581 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 578, 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(578isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(85, 585, 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 __invoking_marker = self.base.push_invoking_state(586isize);
                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);
                let mut __loop_iter_591 = false;
                loop {
                    match self.base.sync_decision(atn(), 591, !__ctx.has_matched_child(), __loop_iter_591) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        83 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        88 => 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 => {
                            __loop_iter_591 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(83, 588, 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(84, 590, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(88, 595, 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(595isize);
                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);
            }
            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 mut __loop_iter_600 = false;
                loop {
                    match self.base.sync_decision(atn(), 600, !__ctx.has_matched_child(), __loop_iter_600) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 600) {
                        __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(53, 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(53, 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(), 600, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_600 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(597isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(603isize);
                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);
            }
            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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    1 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    48 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    49 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        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);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            42 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            1 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            12 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            48 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            49 => 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(), 611, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(605isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(42, 612, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(1, 612, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(12, 612, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(48, 612, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __match = self.base.match_token_recovering(49, 612, 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 mut __loop_iter_616 = false;
                loop {
                    match self.base.sync_decision(atn(), 616, !__ctx.has_matched_child(), __loop_iter_616) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 12 | 42 | 48..=49 | 124 => 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(), 616, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_616 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(613isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(619isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(620isize);
                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);
            }
            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_625 = false;
                loop {
                    match self.base.sync_decision(atn(), 625, !__ctx.has_matched_child(), __loop_iter_625) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 625) {
                        __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(56, 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(56, 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(), 625, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_625 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(622isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(628isize);
                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 __invoking_marker = self.base.push_invoking_state(629isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(630isize);
                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);
                let mut __loop_iter_635 = false;
                loop {
                    match self.base.sync_decision(atn(), 635, !__ctx.has_matched_child(), __loop_iter_635) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        83 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        55 | 81 | 85 => 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(), 635, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_635 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(83, 632, 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(84, 634, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 640, !__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) {
                    55 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 | 85 => 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(), 640, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(55, 639, 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(639isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(642isize);
                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_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 __invoking_marker = self.base.push_invoking_state(644isize);
                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);
                let mut __loop_iter_649 = false;
                loop {
                    match self.base.sync_decision(atn(), 649, !__ctx.has_matched_child(), __loop_iter_649) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 649) {
                        __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(59, 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(59, 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(), 649, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_649 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 646, 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(646isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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 __invoking_marker = self.base.push_invoking_state(652isize);
                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);
                match self.base.sync_decision(atn(), 655, !__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(), 655) {
                    __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(60, 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(60, 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(), 655, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(88, 654, 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(654isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __invoking_marker = self.base.push_invoking_state(657isize);
                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);
                let mut __loop_iter_662 = false;
                loop {
                    match self.base.sync_decision(atn(), 662, !__ctx.has_matched_child(), __loop_iter_662) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 662) {
                        __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(), 662, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_662 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(83, 659, 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(84, 661, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 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 },
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 667, !__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 },
                            3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => 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(), 667, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(665isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(666isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(666isize)).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_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 __match = self.base.match_token_recovering(81, 681, 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(), 681, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 81 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 => 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(), 681, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(670isize);
                        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);
                        let mut __loop_iter_675 = false;
                        loop {
                            match self.base.sync_decision(atn(), 675, !__ctx.has_matched_child(), __loop_iter_675) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 675) {
                                __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(63, 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(63, 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(), 675, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_675 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 672, 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(672isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 679, !__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) {
                            86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            82 => 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(), 679, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(86, 680, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(82, 684, 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_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 {
                match self.base.sync_decision(atn(), 693, !__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(), 693) {
                    __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(67, 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(67, 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(), 693, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(685isize);
                        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 __match = self.base.match_token_recovering(87, 690, 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_690 = false;
                        loop {
                            match self.base.sync_decision(atn(), 690, !__ctx.has_matched_child(), __loop_iter_690) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                17 | 31 | 35..=36 | 41 | 44 | 46 | 56 | 58 | 60 | 66 | 129 => 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(), 690, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_690 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(687isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(695isize);
                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);
                match self.base.sync_decision(atn(), 697, !__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(), 697) {
                    __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(68, 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(68, 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(), 697, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(696isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_701 = true;
                loop {
                    match self.base.sync_decision(atn(), 701, !__ctx.has_matched_child(), __loop_iter_701) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 701) {
                        __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(69, 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(69, 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(), 701, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_701 = true;
                            match self.base.sync_decision(atn(), 693, !__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(), 693) {
                                __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(67, 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(67, 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(), 693, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(685isize);
                                    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 __match = self.base.match_token_recovering(87, 690, 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_690 = false;
                                    loop {
                                        match self.base.sync_decision(atn(), 690, !__ctx.has_matched_child(), __loop_iter_690) {
                                            Ok(__sync_children) => {
                                                for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                            124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                            17 | 31 | 35..=36 | 41 | 44 | 46 | 56 | 58 | 60 | 66 | 129 => 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(), 690, &__prediction);
                                        match __prediction.alt {
                                            1 => {
                                                __loop_iter_690 = true;
                                                if __ctx.context_alt_number() == 0 {
                                                    __ctx.set_context_alt_number(1);
                                                }
                                                let __invoking_marker = self.base.push_invoking_state(687isize);
                                                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 => {
                                                if __ctx.context_alt_number() == 0 {
                                                    __ctx.set_context_alt_number(2);
                                                }
                                                break;
                                            }
                                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                        }
                                    }
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                            let __invoking_marker = self.base.push_invoking_state(695isize);
                            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);
                            match self.base.sync_decision(atn(), 697, !__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(), 697) {
                                __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(68, 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(68, 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(), 697, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(696isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let mut __loop_iter_716 = false;
                loop {
                    match self.base.sync_decision(atn(), 716, !__ctx.has_matched_child(), __loop_iter_716) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 716) {
                        __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(72, 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(72, 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(), 716, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_716 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(87, 707, 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_707 = false;
                            loop {
                                match self.base.sync_decision(atn(), 707, !__ctx.has_matched_child(), __loop_iter_707) {
                                    Ok(__sync_children) => {
                                        for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                    124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    17 | 31 | 35..=36 | 41 | 44 | 46 | 56 | 58 | 60 | 66 | 129 => 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(), 707, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        __loop_iter_707 = true;
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __invoking_marker = self.base.push_invoking_state(704isize);
                                        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 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(2);
                                        }
                                        break;
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                            let __invoking_marker = self.base.push_invoking_state(710isize);
                            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);
                            match self.base.sync_decision(atn(), 712, !__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(), 712) {
                                __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(), 712, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(711isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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(719isize);
                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);
                let mut __loop_iter_724 = false;
                loop {
                    match self.base.sync_decision(atn(), 724, !__ctx.has_matched_child(), __loop_iter_724) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 724) {
                        __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(73, 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(73, 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(), 724, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_724 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(87, 721, 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(721isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 739, !__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(), 739) {
                            __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(), 739, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(727isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let mut __loop_iter_731 = false;
                        loop {
                            match self.base.sync_decision(atn(), 731, !__ctx.has_matched_child(), __loop_iter_731) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                124 => 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 },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 731, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_731 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(728isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(93, 737, 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(), 737, !__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) {
                            18 | 50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            86 | 89 => 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(), 737, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_set_recovering(&[(18, 18), (50, 50)], 736, 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(736isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(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_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 __invoking_marker = self.base.push_invoking_state(741isize);
                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);
                let mut __loop_iter_746 = false;
                loop {
                    match self.base.sync_decision(atn(), 746, !__ctx.has_matched_child(), __loop_iter_746) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        81 | 85 => 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(), 746, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_746 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 743, 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(743isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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(79, 761, 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(), 761, !__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 | 5 | 8 | 14 | 17 | 19 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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(), 761, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            19 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 752, !__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(), 752) {
                                    __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(78, 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(78, 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(), 752, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(750isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __invoking_marker = self.base.push_invoking_state(751isize);
                                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)),
                        }
                        let mut __loop_iter_758 = false;
                        loop {
                            match self.base.sync_decision(atn(), 758, !__ctx.has_matched_child(), __loop_iter_758) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                86 => 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(), 758, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_758 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 755, 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(755isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(80, 764, 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 __invoking_marker = self.base.push_invoking_state(765isize);
                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);
                let mut __loop_iter_771 = false;
                loop {
                    match self.base.sync_decision(atn(), 771, !__ctx.has_matched_child(), __loop_iter_771) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        53 => 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(), 771, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_771 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(766isize);
                            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);
                            let __match = self.base.match_token_recovering(87, 768, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(53, 775, 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(776isize);
                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);
                let mut __loop_iter_781 = false;
                loop {
                    match self.base.sync_decision(atn(), 781, !__ctx.has_matched_child(), __loop_iter_781) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 781) {
                        __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(82, 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(82, 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(), 781, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_781 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 778, 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(778isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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_787 = false;
                loop {
                    match self.base.sync_decision(atn(), 787, !__ctx.has_matched_child(), __loop_iter_787) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 787) {
                        __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(83, 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(83, 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(), 787, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_787 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(784isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(790isize);
                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);
                match self.base.sync_decision(atn(), 798, !__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) {
                    124..=125 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 798, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_794 = false;
                        loop {
                            match self.base.sync_decision(atn(), 794, !__ctx.has_matched_child(), __loop_iter_794) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                125 => 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(), 794, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_794 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(791isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(125, 799, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(800isize);
                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);
            }
            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 {
                let __invoking_marker = self.base.push_invoking_state(802isize);
                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);
                let mut __loop_iter_807 = false;
                loop {
                    match self.base.sync_decision(atn(), 807, !__ctx.has_matched_child(), __loop_iter_807) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => 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 },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 807, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_807 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 804, 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(804isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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_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) {
                        19 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        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(), 813, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_813 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(810isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(61, 817, 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(817isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(819isize);
                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);
                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 = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 824) {
                        __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(88, 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(88, 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(), 824, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_824 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(87, 821, 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(821isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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) {
                    68..=71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    75 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    76 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    74 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    78 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    77 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 834, !__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) {
                            68..=71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            72..=73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            75 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            76 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            74 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            78 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            77 => antlr4_runtime::ParserAtnPrediction { alt: 7, 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(), 834, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(827isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(828isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(75, 835, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(76, 835, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(74, 835, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __match = self.base.match_token_recovering(78, 835, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __match = self.base.match_token_recovering(77, 835, 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_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 __match = self.base.match_set_recovering(&[(68, 71)], 837, 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_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_set_recovering(&[(72, 73)], 839, 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 __match = self.base.match_token_recovering(124, 841, 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(841isize);
                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);
                match self.base.sync_decision(atn(), 844, !__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) {
                    79 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    1 | 3 | 5 | 8..=9 | 12 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 80 | 82..=83 | 85..=86 | 90 | 93 | 124..=125 | 129 => 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(), 844, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(843isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => 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 __match = self.base.match_token_recovering(79, 855, 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(), 855, !__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(), 855) {
                    __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(), 855, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(847isize);
                        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 __loop_iter_852 = false;
                        loop {
                            match self.base.sync_decision(atn(), 852, !__ctx.has_matched_child(), __loop_iter_852) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                86 => 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(), 852, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_852 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 849, 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(849isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(80, 858, 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_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 __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(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),
                        })?
                };
                let __prediction = if __prediction.has_semantic_context {
                    let __semantic_la = self.base.la(1);
                    let __semantic_alt = match __prediction.alt {
                        1 if self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 58, 0, &__ctx, __precedence) => Some(1),
                        1 => {
                            if self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 58, 0, &__ctx, __precedence) {
                                Some(1)
                            } else
                            if true {
                                Some(2)
                            } else
                            { None }
                        }
                        _ => Some(__prediction.alt),
                    };
                    match __semantic_alt {
                        Some(__alt) => antlr4_runtime::ParserAtnPrediction { alt: __alt, ..__prediction },
                        None => {
                            let __error = self.base.no_viable_alternative_error(__decision_start);
                            return Err(__error);
                        }
                    }
                } else {
                    __prediction
                };
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 58, 0, &__ctx, __precedence) {
                            if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(58, 0, parser_semantics()) {
                                return Err(self.base.failed_predicate_option_error(58, __message));
                            }
                            return Err(self.base.failed_predicate_error("semantic predicate"));
                        }
                        let __invoking_marker = self.base.push_invoking_state(860isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(861isize);
                        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);
                        let __match = self.base.match_token_recovering(88, 863, 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(863isize);
                        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_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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 884, !__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(), 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(97, 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(97, 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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(867isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(867isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(868isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(81, 878, 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(), 878, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 81 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            82 | 86 => 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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(870isize);
                                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);
                                let mut __loop_iter_875 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 875, !__ctx.has_matched_child(), __loop_iter_875) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 875) {
                                        __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(94, 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(94, 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(), 875, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_875 = true;
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __match = self.base.match_token_recovering(86, 872, 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(872isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        match self.base.sync_decision(atn(), 881, !__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) {
                            86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            82 => 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(), 881, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(86, 882, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(82, 885, 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) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    81 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        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);
                            }
                        }
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        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(98, 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(98, 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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(886isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(886isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(887isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(888isize);
                        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);
                    }
                    _ => 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 __match = self.base.match_token_recovering(81, 900, 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(), 900, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 81 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 | 86 => 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(), 900, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(892isize);
                        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);
                        let mut __loop_iter_897 = false;
                        loop {
                            match self.base.sync_decision(atn(), 897, !__ctx.has_matched_child(), __loop_iter_897) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 897) {
                                __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(99, 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(99, 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(), 897, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_897 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 894, 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(894isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                match self.base.sync_decision(atn(), 903, !__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) {
                    86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    82 => 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(), 903, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(86, 904, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(82, 906, 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_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(124, 908, 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(29, 909, 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(909isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(910isize);
                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);
            }
            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 {
                let __match = self.base.match_token_recovering(81, 916, 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_916 = false;
                loop {
                    match self.base.sync_decision(atn(), 916, !__ctx.has_matched_child(), __loop_iter_916) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=61 | 63..=64 | 66..=67 | 85 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 916, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_916 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(913isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 920, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    1 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=61 | 63..=64 | 66..=67 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 929, !__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 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=61 | 63..=64 | 66..=67 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 929, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_924 = false;
                        loop {
                            match self.base.sync_decision(atn(), 924, !__ctx.has_matched_child(), __loop_iter_924) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 924) {
                                __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(), 924, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_924 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(921isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(927isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(85, 930, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    16 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 955, !__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(), 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(110, 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(110, 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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(931isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(932isize);
                        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 __match = self.base.match_token_recovering(85, 934, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(935isize);
                        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(), 937, !__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(), 937) {
                            __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(105, 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(105, 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(), 937, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 938, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(939isize);
                        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);
                        match self.base.sync_decision(atn(), 941, !__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(), 941) {
                            __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(106, 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(106, 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(), 941, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 942, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(943isize);
                        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);
                        match self.base.sync_decision(atn(), 945, !__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(), 945) {
                            __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(107, 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(107, 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(), 945, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 946, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(947isize);
                        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);
                        match self.base.sync_decision(atn(), 949, !__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(), 949) {
                            __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(), 949, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 950, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __invoking_marker = self.base.push_invoking_state(951isize);
                        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);
                        match self.base.sync_decision(atn(), 953, !__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(), 953) {
                            __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(), 953, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 954, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(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_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 {
                match self.base.sync_decision(atn(), 959, !__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(), 959) {
                    __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(111, 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(111, 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(), 959, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(957isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(958isize);
                        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);
                    }
                    _ => 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 __invoking_marker = self.base.push_invoking_state(961isize);
                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);
                let __match = self.base.match_token_recovering(79, 963, 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(80, 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) {
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => 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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(964isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => 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 __invoking_marker = self.base.push_invoking_state(967isize);
                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);
            }
            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 __match = self.base.match_token_recovering(12, 970, 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(970isize);
                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);
            }
            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_975 = false;
                loop {
                    match self.base.sync_decision(atn(), 975, !__ctx.has_matched_child(), __loop_iter_975) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        31 | 35 => 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(), 975, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_975 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(972isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                match self.base.sync_decision(atn(), 979, !__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) {
                    35 => 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(), 979, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(35, 980, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(31, 982, 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(982isize);
                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);
                let __match = self.base.match_token_recovering(81, 987, 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_987 = false;
                loop {
                    match self.base.sync_decision(atn(), 987, !__ctx.has_matched_child(), __loop_iter_987) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        17 | 36 | 41 | 44 | 60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 987, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_987 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(984isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 991, 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_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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    44 => 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 },
                    36 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    60 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    41 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1049, !__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) {
                            44 => 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 },
                            36 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            60 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            41 => 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(), 1049, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(44, 996, 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_996 = false;
                        loop {
                            match self.base.sync_decision(atn(), 996, !__ctx.has_matched_child(), __loop_iter_996) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 996) {
                                __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(116, 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(116, 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(), 996, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_996 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(993isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(999isize);
                        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);
                        let __match = self.base.match_token_recovering(85, 1001, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(17, 1003, 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(1003isize);
                        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);
                        match self.base.sync_decision(atn(), 1013, !__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) {
                            56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1013, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(56, 1005, 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(1005isize);
                                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);
                                let mut __loop_iter_1010 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 1010, !__ctx.has_matched_child(), __loop_iter_1010) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        85 => 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(), 1010, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1010 = true;
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __match = self.base.match_token_recovering(86, 1007, 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(1007isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1016, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(36, 1018, 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(1018isize);
                        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);
                        match self.base.sync_decision(atn(), 1028, !__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) {
                            56 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1028, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(56, 1020, 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(1020isize);
                                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);
                                let mut __loop_iter_1025 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 1025, !__ctx.has_matched_child(), __loop_iter_1025) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        85 => 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(), 1025, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1025 = true;
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __match = self.base.match_token_recovering(86, 1022, 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(1022isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1031, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(60, 1033, 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(1033isize);
                        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);
                        let __match = self.base.match_token_recovering(85, 1035, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(41, 1037, 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(1037isize);
                        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);
                        let __match = self.base.match_token_recovering(66, 1039, 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(1039isize);
                        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);
                        let mut __loop_iter_1044 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1044, !__ctx.has_matched_child(), __loop_iter_1044) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                85 => 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(), 1044, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1044 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 1041, 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(1041isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(85, 1048, 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_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 __match = self.base.match_set_recovering(&[(48, 48), (58, 58)], 1052, 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_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 __match = self.base.match_token_recovering(43, 1054, 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(1054isize);
                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);
                match self.base.sync_decision(atn(), 1056, !__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) {
                    90 => 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(), 1056, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1055isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1058isize);
                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);
                match self.base.sync_decision(atn(), 1061, !__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) {
                    25 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1061, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(25, 1060, 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(1060isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1063isize);
                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);
            }
            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 __match = self.base.match_token_recovering(79, 1067, 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(), 1067, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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(), 1067, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1066isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(80, 1070, 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 __invoking_marker = self.base.push_invoking_state(1071isize);
                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 mut __loop_iter_1076 = false;
                loop {
                    match self.base.sync_decision(atn(), 1076, !__ctx.has_matched_child(), __loop_iter_1076) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1076) {
                        __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(126, 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(126, 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(), 1076, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1076 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 1073, 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(1073isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                if !self.base.parser_semantic_ir_predicate_matches_with_context_and_local(parser_semantics(), 75, 1, &__ctx, __precedence) {
                    if let Some(__message) = self.base.parser_semantic_ir_predicate_failure_message(75, 1, parser_semantics()) {
                        return Err(self.base.failed_predicate_option_error(75, __message));
                    }
                    return Err(self.base.failed_predicate_error("semantic predicate"));
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_76_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 76, GeneratedRuleError::Fatal; self.parse_generated_rule_76(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_76(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 152isize, 76, 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_1084 = false;
                loop {
                    match self.base.sync_decision(atn(), 1084, !__ctx.has_matched_child(), __loop_iter_1084) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1084) {
                        __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(), 1084, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1084 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1081isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1087isize);
                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);
                match self.base.sync_decision(atn(), 1095, !__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) {
                    124..=125 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1095, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_1091 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1091, !__ctx.has_matched_child(), __loop_iter_1091) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                125 => 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(), 1091, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1091 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1088isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(125, 1096, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1097isize);
                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);
            }
            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 __match = self.base.match_token_recovering(81, 1104, 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_1104 = false;
                loop {
                    match self.base.sync_decision(atn(), 1104, !__ctx.has_matched_child(), __loop_iter_1104) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 3 | 5 | 8..=9 | 14 | 16..=17 | 19 | 21 | 28..=32 | 34..=36 | 38..=44 | 46..=49 | 52 | 56..=58 | 60..=64 | 66..=67 | 81 | 85 | 90 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 1104, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1104 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                3 | 5 | 8..=9 | 14 | 16 | 21 | 28..=30 | 47 | 62 | 81 | 85 | 90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                _ => {
                                    match self.base.sync_decision(atn(), 1102, !__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(), 1102) {
                                        __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(130, 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(130, 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(), 1102, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1100isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1101isize);
                                    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);
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 1108, 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_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(81, 1113, 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_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) {
                        1..=5 | 8..=9 | 11 | 13..=14 | 16..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81 | 85 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1110isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 1117, 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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    1 | 9 | 16 | 29 | 34 | 39..=40 | 42 | 48..=49 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    2 | 4 | 11 | 13 | 22 | 24 | 33 | 45 | 50..=54 | 59 | 62 | 65 | 68..=79 | 81 | 85 | 90..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 3, 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(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(), 1123, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1118isize);
                        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);
                        let __match = self.base.match_token_recovering(85, 1120, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1121isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1122isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1122isize)).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_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 __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 = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 1128) {
                        __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(134, 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(134, 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(), 1128, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1128 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1125isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60 | 64 | 66..=67 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1139, !__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(), 1139) {
                            __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(), 1139, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(61, 1132, 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(1132isize);
                        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);
                        let __match = self.base.match_token_recovering(88, 1134, 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(1134isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1134isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1136isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(1137isize);
                        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);
                    }
                    _ => 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_set_recovering(atn().token_set(4).expect("generated parser token-set index"), 1142, 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 __match = self.base.match_token_set_recovering(atn().token_set(5).expect("generated parser token-set index"), 1144, 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_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 mut __loop_iter_1148 = false;
                loop {
                    match self.base.sync_decision(atn(), 1148, !__ctx.has_matched_child(), __loop_iter_1148) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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 | 19 | 34 | 39..=40 | 42 | 46 | 48..=49 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        9 | 16 | 29 | 43 => 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(), 1148, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1148 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1145isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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) {
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    29 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    16 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1155, !__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) {
                            9 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            29 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            16 => antlr4_runtime::ParserAtnPrediction { alt: 4, 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(), 1155, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1151isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1152isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1153isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1154isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_84_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_84_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_84_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(84, precedence).map_err(GeneratedRuleError::Interpreted);
        }
        __result
    }

    #[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 __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 },
                    2 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    24 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    22 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    65 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    13 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    52 => antlr4_runtime::ParserAtnPrediction { alt: 10, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    45 => antlr4_runtime::ParserAtnPrediction { alt: 11, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    54 => antlr4_runtime::ParserAtnPrediction { alt: 12, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 => antlr4_runtime::ParserAtnPrediction { alt: 13, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 => antlr4_runtime::ParserAtnPrediction { alt: 14, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    85 => antlr4_runtime::ParserAtnPrediction { alt: 16, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5 | 8 | 14 | 21 | 28 | 30 | 33 | 47 | 50 | 53 | 62 | 68..=79 | 90..=92 | 101..=104 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 17, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1280, !__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(), 1280) {
                            __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(), 1280, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1157isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(2, 1159, 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(1159isize);
                        let __child = self.parse_generated_rule_98_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);
                        match self.base.sync_decision(atn(), 1162, !__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) {
                            94 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1162, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(94, 1161, 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(1161isize);
                                let __child = self.parse_generated_rule_98_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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1165, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(24, 1167, 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(79, 1168, 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(1168isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(80, 1170, 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(1170isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1170isize)).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(), 1173, !__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(), 1173) {
                            __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(139, 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(139, 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(), 1173, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(15, 1172, 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(1172isize);
                                let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1172isize)).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 __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(22, 1176, 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(79, 1177, 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(1177isize);
                        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);
                        let __match = self.base.match_token_recovering(80, 1179, 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(1179isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1179isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __match = self.base.match_token_recovering(65, 1182, 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(79, 1183, 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(1183isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(80, 1185, 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(1185isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1185isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __match = self.base.match_token_recovering(13, 1188, 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(1188isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1188isize)).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(65, 1190, 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(79, 1191, 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(1191isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(80, 1193, 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(85, 1194, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __match = self.base.match_token_recovering(59, 1196, 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(1196isize);
                        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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            7 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            20 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1206, !__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) {
                                    7 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    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(), 1206, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1197isize);
                                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);
                                let mut __loop_iter_1200 = true;
                                loop {
                                    match self.base.sync_decision(atn(), 1200, !__ctx.has_matched_child(), __loop_iter_1200) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                        7 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        1..=6 | 8..=9 | 11..=17 | 19..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81..=82 | 85 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1200, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1200 = true;
                                            let __invoking_marker = self.base.push_invoking_state(1197isize);
                                            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);
                                        }
                                        2 => {
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                match self.base.sync_decision(atn(), 1203, !__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) {
                                    20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    1..=6 | 8..=9 | 11..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81..=82 | 85 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1203, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __invoking_marker = self.base.push_invoking_state(1202isize);
                                        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);
                                    }
                                    2 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(2);
                                        }
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1205isize);
                                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);
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    8 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(8);
                        }
                        let __match = self.base.match_token_recovering(59, 1209, 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(1209isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(1210isize);
                        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_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) {
                                7 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                1..=6 | 8..=9 | 11..=17 | 19..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81..=82 | 85 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1214, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1214 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1211isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        match self.base.sync_decision(atn(), 1218, !__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) {
                            20 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            1..=6 | 8..=9 | 11..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81..=82 | 85 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1218, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1217isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    9 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(9);
                        }
                        let __match = self.base.match_token_recovering(51, 1221, 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(79, 1222, 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(1222isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(80, 1224, 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(81, 1228, 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_1228 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1228, !__ctx.has_matched_child(), __loop_iter_1228) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1228) {
                                __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(145, 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(145, 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(), 1228, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1228 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1225isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let mut __loop_iter_1234 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1234, !__ctx.has_matched_child(), __loop_iter_1234) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                6 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                82 => 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(), 1234, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1234 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1231isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(82, 1238, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    10 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(10);
                        }
                        let __match = self.base.match_token_recovering(52, 1240, 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(79, 1241, 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(1241isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(80, 1243, 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(1243isize);
                        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);
                    }
                    11 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(11);
                        }
                        let __match = self.base.match_token_recovering(45, 1247, 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(), 1247, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1247, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1246isize);
                                let __child = self.parse_generated_rule_98_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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1281, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    12 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(12);
                        }
                        let __match = self.base.match_token_recovering(54, 1251, 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(1251isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(85, 1253, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    13 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(13);
                        }
                        let __match = self.base.match_token_recovering(4, 1256, 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(), 1256, !__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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1256, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1255isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1281, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    14 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(14);
                        }
                        let __match = self.base.match_token_recovering(11, 1261, 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(), 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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1261, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1260isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1281, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    15 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(15);
                        }
                        let __match = self.base.match_token_recovering(67, 1265, 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(1265isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(85, 1267, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    16 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(16);
                        }
                        let __match = self.base.match_token_recovering(85, 1281, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    17 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(17);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1269isize);
                        let __child = self.parse_generated_rule_98_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 __match = self.base.match_token_recovering(85, 1271, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    18 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(18);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1272isize);
                        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);
                        match self.base.sync_decision(atn(), 1274, !__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(), 1274) {
                            __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(), 1274, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __match = self.base.match_token_recovering(85, 1275, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    19 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(19);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1276isize);
                        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);
                        let __match = self.base.match_token_recovering(94, 1278, 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(1278isize);
                        let __child = if self.adaptive_atn_preferred_rules[0] { self.parse_rule_precedence_from_generated(84, 0) } else { self.parse_generated_rule_84_adaptive_dispatch(0, false, Some(1278isize)).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_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_token_recovering(7, 1283, 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(79, 1287, 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_1287 = false;
                loop {
                    match self.base.sync_decision(atn(), 1287, !__ctx.has_matched_child(), __loop_iter_1287) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        19 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1287, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1287 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1284isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __invoking_marker = self.base.push_invoking_state(1290isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(1291isize);
                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);
                let __match = self.base.match_token_recovering(80, 1293, 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(1293isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(1295isize);
                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);
                let mut __loop_iter_1300 = false;
                loop {
                    match self.base.sync_decision(atn(), 1300, !__ctx.has_matched_child(), __loop_iter_1300) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        108 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1300, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1300 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(108, 1297, 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(1297isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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(20, 1304, 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(1304isize);
                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);
            }
            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(79, 1307, 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(1307isize);
                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);
                match self.base.sync_decision(atn(), 1309, !__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) {
                    85 => 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(), 1309, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(85, 1310, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(80, 1312, 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(1313isize);
                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_1318 = false;
                loop {
                    match self.base.sync_decision(atn(), 1318, !__ctx.has_matched_child(), __loop_iter_1318) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1318) {
                        __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(155, 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(155, 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(), 1318, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1318 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(85, 1315, 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(1315isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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) {
                    19 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1338, !__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(), 1338) {
                            __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(), 1338, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_1324 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1324, !__ctx.has_matched_child(), __loop_iter_1324) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                19 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1324, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1324 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1321isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1332, !__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(), 1332) {
                                    __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(157, 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(157, 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(), 1332, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1327isize);
                                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);
                                let __invoking_marker = self.base.push_invoking_state(1328isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __match = self.base.match_token_recovering(61, 1331, 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(1331isize);
                                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);
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(88, 1335, 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(1335isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1335isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1337isize);
                        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_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 __invoking_marker = self.base.push_invoking_state(1340isize);
                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);
                let __match = self.base.match_token_recovering(94, 1342, 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_1345 = true;
                loop {
                    match self.base.sync_decision(atn(), 1345, !__ctx.has_matched_child(), __loop_iter_1345) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        6 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        1..=5 | 8..=9 | 11 | 13..=14 | 16..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81 | 85 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1345, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1345 = true;
                            let __invoking_marker = self.base.push_invoking_state(1340isize);
                            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);
                            let __match = self.base.match_token_recovering(94, 1342, 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 __invoking_marker = self.base.push_invoking_state(1347isize);
                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);
                let mut __loop_iter_1350 = true;
                loop {
                    match self.base.sync_decision(atn(), 1350, !__ctx.has_matched_child(), __loop_iter_1350) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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..=5 | 8..=9 | 11 | 13..=14 | 16..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81 | 85 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        6 | 12 | 82 => 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(), 1350, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1350 = true;
                            let __invoking_marker = self.base.push_invoking_state(1347isize);
                            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 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    6 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 1361, !__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) {
                            6 => 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(), 1361, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(6, 1358, 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) {
                            33 | 50..=51 | 53 | 62 | 68..=79 | 90..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1358, !__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(), 1358) {
                                    __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(), 1358, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1353isize);
                                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1353isize)).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 __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __match = self.base.match_token_recovering(129, 1359, atn())?;
                                __consumed_eof |= __match.consumed_eof();
                                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                            }
                            3 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(3);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1355isize);
                                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);
                                let __invoking_marker = self.base.push_invoking_state(1356isize);
                                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);
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(12, 1362, 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_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 {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    33 | 50..=51 | 53 | 62 | 68..=79 | 85 | 90..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1375, !__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(), 1375) {
                            __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(166, 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(166, 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(), 1375, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1363isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        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 = match self.base.la(1) {
                            3 | 5 | 8 | 14 | 17 | 19 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1365, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1364isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1369, 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(), 1369, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            85 => 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(), 1369, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1368isize);
                                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1368isize)).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 __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(85, 1373, 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(), 1373, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => 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 },
                            _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 1373, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1372isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(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_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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    19 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 | 50..=51 | 53 | 62 | 68..=79 | 90..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1379, !__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(), 1379) {
                            __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(), 1379, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1377isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1378isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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_1384 = false;
                loop {
                    match self.base.sync_decision(atn(), 1384, !__ctx.has_matched_child(), __loop_iter_1384) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1384) {
                        __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(168, 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(168, 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(), 1384, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1384 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1381isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60 | 64 | 66..=67 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1389, !__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(), 1389) {
                            __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(), 1389, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1387isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(61, 1390, 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(1391isize);
                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 __match = self.base.match_token_recovering(94, 1393, 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(1393isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1393isize)).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 __invoking_marker = self.base.push_invoking_state(1395isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1395isize)).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_1400 = false;
                loop {
                    match self.base.sync_decision(atn(), 1400, !__ctx.has_matched_child(), __loop_iter_1400) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        80 | 85 | 94 | 122 => 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(), 1400, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1400 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 1397, 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(1397isize);
                            let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1397isize)).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 __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    50 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1406, !__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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            50 => 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(), 1406, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1403isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(53, 1407, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(50, 1407, 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(1408isize);
                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);
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98_adaptive_probe_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let __result = self.parse_generated_rule_98_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_98_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_98_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_98_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(98, precedence).map_err(GeneratedRuleError::Interpreted);
        }
        __result
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 98, GeneratedRuleError::Fatal; self.parse_generated_rule_98_precedence(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98(&mut self, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        self.parse_generated_rule_98_precedence(0, allow_fallback)
    }

    #[allow(dead_code)]
    fn parse_generated_rule_98_precedence(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        antlr4_runtime::__antlr4_rust_generated_rule! {
            recursive self, 196isize, 98, __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) {
                    62 | 68..=78 | 90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    51 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    91..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 => antlr4_runtime::ParserAtnPrediction { alt: 8, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1453, !__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(), 1453) {
                            __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(177, 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(177, 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(), 1453, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let action = self.base.parser_action_at_current_indexed(1410, 98, 0, __rule_start, __consumed_eof);
                        let _ = action;
                        let __invoking_marker = self.base.push_invoking_state(1411isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1412isize);
                        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);
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1413isize);
                        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);
                        let __match = self.base.match_token_recovering(123, 1420, 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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 90 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            33 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1420, !__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) {
                                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 90 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    33 => 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(), 1420, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                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) {
                                    90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1416, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __invoking_marker = self.base.push_invoking_state(1415isize);
                                        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);
                                    }
                                    2 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(2);
                                        }
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                                let __invoking_marker = self.base.push_invoking_state(1418isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __match = self.base.match_token_recovering(33, 1421, 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)),
                        }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1422isize);
                        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);
                        let __match = self.base.match_token_recovering(123, 1425, 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(), 1425, !__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) {
                            90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            33 => 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(), 1425, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1424isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(33, 1428, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1429isize);
                        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);
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __match = self.base.match_set_recovering(&[(91, 92), (101, 104)], 1431, 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(1431isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 17) } else { self.parse_generated_rule_98_adaptive_dispatch(17, false, Some(1431isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __match = self.base.match_token_recovering(79, 1436, 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_1436 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1436, !__ctx.has_matched_child(), __loop_iter_1436) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1436) {
                                __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(175, 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(175, 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(), 1436, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1436 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1433isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(1439isize);
                        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);
                        let mut __loop_iter_1444 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1444, !__ctx.has_matched_child(), __loop_iter_1444) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                107 => 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(), 1444, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1444 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(107, 1441, 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(1441isize);
                                    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);
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(80, 1448, 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(1448isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 16) } else { self.parse_generated_rule_98_adaptive_dispatch(16, false, Some(1448isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(8);
                        }
                        let __match = self.base.match_token_recovering(33, 1451, 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(1451isize);
                        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);
                    }
                    9 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(9);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1452isize);
                        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);
                    }
                    _ => 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(), 1538, __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(184, __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(), 1538, &__prediction);
                    match __prediction.alt {
                        1 => {
                            self.base.parse_listener_exit_rule(98);
                            if let Some(__depth_error) = self.base.rule_depth_cap_violation() {
                                return Err(__depth_error);
                            }
                            self.base.push_new_recursion_context_with_previous(196isize, 98, &mut __ctx);
                            if let Some(__listener_error) = self.base.parse_listener_enter_rule(98) {
                                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(183, 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 __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    if !self.base.precpred(25) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 25)"));
                                    }
                                    let __match = self.base.match_token_recovering(83, 1457, 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(1457isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1457isize)).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(84, 1459, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    if !self.base.precpred(24) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 24)"));
                                    }
                                    let __match = self.base.match_token_recovering(87, 1473, 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(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),
                                            })?
                                    };
                                    match __prediction.alt {
                                        1 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1462isize);
                                            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 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1463isize);
                                            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);
                                        }
                                        3 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(3);
                                            }
                                            let __match = self.base.match_token_recovering(53, 1474, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        4 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(4);
                                            }
                                            let __match = self.base.match_token_recovering(33, 1467, 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(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),
                                                    })?
                                            };
                                            match __prediction.alt {
                                                1 => {
                                                    if __ctx.context_alt_number() == 0 {
                                                        __ctx.set_context_alt_number(1);
                                                    }
                                                    let __invoking_marker = self.base.push_invoking_state(1466isize);
                                                    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);
                                                }
                                                2 => {
                                                    if __ctx.context_alt_number() == 0 {
                                                        __ctx.set_context_alt_number(2);
                                                    }
                                                }
                                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1469isize);
                                            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);
                                        }
                                        5 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(5);
                                            }
                                            let __match = self.base.match_token_recovering(50, 1471, 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(1471isize);
                                            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);
                                        }
                                        6 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(6);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1472isize);
                                            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);
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                3 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(3);
                                    }
                                    if !self.base.precpred(22) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 22)"));
                                    }
                                    let __match = self.base.match_token_recovering(123, 1478, 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(180, 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 __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1477isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1480isize);
                                    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);
                                }
                                4 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(4);
                                    }
                                    if !self.base.precpred(18) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 18)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(101, 102)], 1537, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                5 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(5);
                                    }
                                    if !self.base.precpred(14) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 14)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(105, 106), (110, 110)], 1485, 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(1485isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 15) } else { self.parse_generated_rule_98_adaptive_dispatch(15, false, Some(1485isize)).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 __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(6);
                                    }
                                    if !self.base.precpred(13) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 13)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(103, 104)], 1488, 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(1488isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 14) } else { self.parse_generated_rule_98_adaptive_dispatch(14, false, Some(1488isize)).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 __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(7);
                                    }
                                    if !self.base.precpred(12) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 12)"));
                                    }
                                    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(181, 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),
                                            })?
                                    };
                                    if self.base.report_diagnostic_errors() {
                                        let __diagnostic_la = self.base.la(1);
                                        let mut __diagnostic_alts = Vec::new();
                                        if __diagnostic_la == 90 {
                                            __diagnostic_alts.push(1);
                                        }
                                        if __diagnostic_la == 89 {
                                            __diagnostic_alts.push(2);
                                        }
                                        if __diagnostic_la == 89 {
                                            __diagnostic_alts.push(3);
                                        }
                                        self.base.record_generated_ambiguity_diagnostic(atn(), 1497, __decision_start, __decision_start, &__diagnostic_alts);
                                    }
                                    match __prediction.alt {
                                        1 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __match = self.base.match_token_recovering(90, 1491, 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(90, 1498, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            let __match = self.base.match_token_recovering(89, 1493, 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(89, 1494, 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(89, 1498, atn())?;
                                            __consumed_eof |= __match.consumed_eof();
                                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                        }
                                        3 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(3);
                                            }
                                            let __match = self.base.match_token_recovering(89, 1496, 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(89, 1498, 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(1499isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 13) } else { self.parse_generated_rule_98_adaptive_dispatch(13, false, Some(1499isize)).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 __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(8);
                                    }
                                    if !self.base.precpred(11) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 11)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(89, 90), (96, 97)], 1502, 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(1502isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 12) } else { self.parse_generated_rule_98_adaptive_dispatch(12, false, Some(1502isize)).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 __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(9);
                                    }
                                    if !self.base.precpred(10) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 10)"));
                                    }
                                    let __match = self.base.match_token_recovering(27, 1507, 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(182, 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 __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1505isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1506isize);
                                            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);
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                10 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(10);
                                    }
                                    if !self.base.precpred(9) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 9)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(95, 95), (98, 98)], 1511, 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(1511isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 10) } else { self.parse_generated_rule_98_adaptive_dispatch(10, false, Some(1511isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                11 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(11);
                                    }
                                    if !self.base.precpred(8) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 8)"));
                                    }
                                    let __match = self.base.match_token_recovering(107, 1514, 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(1514isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 9) } else { self.parse_generated_rule_98_adaptive_dispatch(9, false, Some(1514isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                12 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(12);
                                    }
                                    if !self.base.precpred(7) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 7)"));
                                    }
                                    let __match = self.base.match_token_recovering(109, 1517, 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(1517isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 8) } else { self.parse_generated_rule_98_adaptive_dispatch(8, false, Some(1517isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                13 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(13);
                                    }
                                    if !self.base.precpred(6) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 6)"));
                                    }
                                    let __match = self.base.match_token_recovering(108, 1520, 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(1520isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 7) } else { self.parse_generated_rule_98_adaptive_dispatch(7, false, Some(1520isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                14 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(14);
                                    }
                                    if !self.base.precpred(5) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 5)"));
                                    }
                                    let __match = self.base.match_token_recovering(99, 1523, 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(1523isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 6) } else { self.parse_generated_rule_98_adaptive_dispatch(6, false, Some(1523isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                15 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(15);
                                    }
                                    if !self.base.precpred(4) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 4)"));
                                    }
                                    let __match = self.base.match_token_recovering(100, 1526, 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(1526isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 5) } else { self.parse_generated_rule_98_adaptive_dispatch(5, false, Some(1526isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                16 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(16);
                                    }
                                    if !self.base.precpred(3) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 3)"));
                                    }
                                    let __match = self.base.match_token_recovering(93, 1529, 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(1529isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1529isize)).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(94, 1531, 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(1531isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 3) } else { self.parse_generated_rule_98_adaptive_dispatch(3, false, Some(1531isize)).map_err(GeneratedRuleError::into_error) };
                                    self.base.discard_invoking_state(__invoking_marker);
                                    let __child = __child?;
                                    self.base.add_parse_child(&mut __ctx, __child);
                                }
                                17 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(17);
                                    }
                                    if !self.base.precpred(2) {
                                        return Err(self.base.failed_predicate_error("precpred(_ctx, 2)"));
                                    }
                                    let __match = self.base.match_set_recovering(&[(88, 88), (111, 121)], 1535, 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(1535isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 2) } else { self.parse_generated_rule_98_adaptive_dispatch(2, false, Some(1535isize)).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_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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    19 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1563, !__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(), 1563) {
                            __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(188, 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(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),
                                    })?
                            } else {
                                __prediction
                            }
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1563, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let mut __loop_iter_1544 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1544, !__ctx.has_matched_child(), __loop_iter_1544) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1544) {
                                __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(), 1544, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1544 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1541isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(1547isize);
                        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);
                        let mut __loop_iter_1551 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1551, !__ctx.has_matched_child(), __loop_iter_1551) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1551, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1551 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1548isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __invoking_marker = self.base.push_invoking_state(1554isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1556isize);
                        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);
                        let __match = self.base.match_token_recovering(79, 1559, 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(), 1559, !__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 | 5 | 8 | 14 | 17 | 19 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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(), 1559, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1558isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(80, 1562, 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_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 __invoking_marker = self.base.push_invoking_state(1565isize);
                let __child = self.parse_generated_rule_101_dispatch(0, 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_1570 = false;
                loop {
                    match self.base.sync_decision(atn(), 1570, !__ctx.has_matched_child(), __loop_iter_1570) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => 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 },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 1570, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1570 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 1567, 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(1567isize);
                            let __child = self.parse_generated_rule_101_dispatch(0, false).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 __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

    #[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 __invoking_marker = self.base.push_invoking_state(1573isize);
                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);
            }
            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 __invoking_marker = self.base.push_invoking_state(1575isize);
                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);
                let __match = self.base.match_token_recovering(122, 1577, 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(1577isize);
                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);
            }
            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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1601, !__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(), 1601) {
                            __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(193, 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(193, 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(), 1601, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1579isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(79, 1582, 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(), 1582, !__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 | 5 | 8 | 14 | 17 | 19 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 124 | 129 => 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(), 1582, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1581isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(80, 1602, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(79, 1586, 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(1586isize);
                        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);
                        let mut __loop_iter_1591 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1591, !__ctx.has_matched_child(), __loop_iter_1591) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                86 => 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(), 1591, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1591 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(86, 1588, 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(1588isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        let __match = self.base.match_token_recovering(80, 1595, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __match = self.base.match_token_recovering(79, 1598, 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(), 1598, !__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) {
                            19 | 61 | 124 => 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(), 1598, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1597isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __match = self.base.match_token_recovering(80, 1602, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 1605, !__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) {
                            3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => 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 },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 1605, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1603isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1603isize)).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 __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1604isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    79 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    50 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    68..=78 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5 | 8 | 14 | 21 | 28 | 30 | 47 | 62 | 124 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 7, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1625, !__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(), 1625) {
                            __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(196, 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(196, 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(), 1625, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(79, 1608, 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(1608isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1608isize)).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(80, 1610, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(53, 1626, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    3 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(3);
                        }
                        let __match = self.base.match_token_recovering(50, 1626, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    4 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(4);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1613isize);
                        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);
                    }
                    5 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(5);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1614isize);
                        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);
                    }
                    6 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(6);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1615isize);
                        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(87, 1617, 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(9, 1618, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    7 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(7);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1619isize);
                        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);
                        let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 50 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            53 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1623, !__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) {
                                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 50 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    53 => 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(), 1623, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1620isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __match = self.base.match_token_recovering(53, 1622, 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(1622isize);
                                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);
                            }
                            _ => 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_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 __match = self.base.match_token_recovering(51, 1628, 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(79, 1629, 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(1629isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1629isize)).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(80, 1631, 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(81, 1635, 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_1635 = false;
                loop {
                    match self.base.sync_decision(atn(), 1635, !__ctx.has_matched_child(), __loop_iter_1635) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        6 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        82 => 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(), 1635, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1635 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1632isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(82, 1639, 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 __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    6 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 1665, !__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) {
                            6 => 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(), 1665, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(6, 1658, 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) {
                            33 | 50..=51 | 53 | 62 | 68..=77 | 79 | 90..=92 | 101..=104 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            19 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                match self.base.sync_decision(atn(), 1658, !__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(), 1658) {
                                    __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(201, 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(201, 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(), 1658, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1641isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                                let __match = self.base.match_token_recovering(78, 1645, 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(), 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) {
                                    86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    94 | 122 => 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 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __match = self.base.match_token_recovering(86, 1644, 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(12, 1646, atn())?;
                                        __consumed_eof |= __match.consumed_eof();
                                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                    }
                                    2 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(2);
                                        }
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                            3 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(3);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1647isize);
                                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);
                                let mut __loop_iter_1652 = false;
                                loop {
                                    match self.base.sync_decision(atn(), 1652, !__ctx.has_matched_child(), __loop_iter_1652) {
                                        Ok(__sync_children) => {
                                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        64 | 94 | 122 => 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(), 1652, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            __loop_iter_1652 = true;
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __match = self.base.match_token_recovering(86, 1649, 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(1649isize);
                                            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);
                                        }
                                        2 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                            break;
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                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 = match self.base.la(1) {
                                    64 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    94 | 122 => 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(), 1656, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __invoking_marker = self.base.push_invoking_state(1655isize);
                                        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);
                                    }
                                    2 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(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_set_recovering(&[(94, 94), (122, 122)], 1661, 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(1661isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(12, 1663, 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(&[(94, 94), (122, 122)], 1664, 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(1664isize);
                        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);
                    }
                    _ => 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 __match = self.base.match_token_recovering(64, 1668, 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(1668isize);
                let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1668isize)).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 __invoking_marker = self.base.push_invoking_state(1670isize);
                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);
            }
            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 {
                match self.base.sync_decision(atn(), 1679, !__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(), 1679) {
                    __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(204, 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(204, 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(), 1679, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1672isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let mut __loop_iter_1676 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1676, !__ctx.has_matched_child(), __loop_iter_1676) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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..=5 | 8..=9 | 11 | 13..=14 | 16..=17 | 19 | 21..=22 | 24 | 28..=31 | 33..=36 | 38..=54 | 56 | 58..=62 | 64..=79 | 81 | 85 | 90..=92 | 101..=104 | 124 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                6 | 12 | 82 => 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(), 1676, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1676 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __invoking_marker = self.base.push_invoking_state(1673isize);
                                    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 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => 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_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(1681isize);
                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);
            }
            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) {
                    90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1692, !__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(), 1692) {
                            __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(), 1692, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        match self.base.sync_decision(atn(), 1684, !__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) {
                            90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1684, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1683isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __invoking_marker = self.base.push_invoking_state(1686isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(1687isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1689isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(1690isize);
                        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);
                    }
                    _ => 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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5 | 8 | 14 | 21 | 28 | 30 | 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1709, !__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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            3 | 5 | 8 | 14 | 21 | 28 | 30 | 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(), 1709, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1694isize);
                        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);
                        match self.base.sync_decision(atn(), 1696, !__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) {
                            90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            79 | 83 | 87 => 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(), 1696, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1695isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let mut __loop_iter_1705 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1705, !__ctx.has_matched_child(), __loop_iter_1705) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                87 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                79 | 83 => 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(), 1705, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1705 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(87, 1699, 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(1699isize);
                                    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);
                                    match self.base.sync_decision(atn(), 1701, !__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) {
                                        90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                        79 | 83 | 87 => 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(), 1701, &__prediction);
                                    match __prediction.alt {
                                        1 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(1);
                                            }
                                            let __invoking_marker = self.base.push_invoking_state(1700isize);
                                            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 => {
                                            if __ctx.context_alt_number() == 0 {
                                                __ctx.set_context_alt_number(2);
                                            }
                                        }
                                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                    }
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1708isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_114_dispatch(&mut self, precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! { dispatch self, 114, GeneratedRuleError::Fatal; self.parse_generated_rule_114(precedence, allow_fallback) }
    }

    #[allow(dead_code)]
    fn parse_generated_rule_114(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 228isize, 114, 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(1711isize);
                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);
                match self.base.sync_decision(atn(), 1713, !__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) {
                    90 => 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(), 1713, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1712isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __invoking_marker = self.base.push_invoking_state(1715isize);
                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);
            }
            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 {
                match self.base.sync_decision(atn(), 1739, !__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(), 1739) {
                    __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(215, 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(215, 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(), 1739, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(83, 1718, 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(84, 1720, 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_1721 = true;
                        loop {
                            match self.base.sync_decision(atn(), 1721, !__ctx.has_matched_child(), __loop_iter_1721) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                83 => 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 },
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            };
                            self.base.record_generated_prediction_diagnostic(atn(), 1721, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1721 = true;
                                    let __match = self.base.match_token_recovering(83, 1718, 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(84, 1720, 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 __invoking_marker = self.base.push_invoking_state(1723isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(83, 1725, 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(1725isize);
                        let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1725isize)).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(84, 1727, 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_1730 = true;
                        loop {
                            match self.base.sync_decision(atn(), 1730, !__ctx.has_matched_child(), __loop_iter_1730) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1730) {
                                __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(213, 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(213, 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(), 1730, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1730 = true;
                                    let __match = self.base.match_token_recovering(83, 1725, 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(1725isize);
                                    let __child = if self.adaptive_atn_preferred_rules[1] { self.parse_rule_precedence_from_generated(98, 0) } else { self.parse_generated_rule_98_adaptive_dispatch(0, false, Some(1725isize)).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(84, 1727, 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 mut __loop_iter_1736 = false;
                        loop {
                            match self.base.sync_decision(atn(), 1736, !__ctx.has_matched_child(), __loop_iter_1736) {
                                Ok(__sync_children) => {
                                    for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1736) {
                                __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(214, 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(214, 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(), 1736, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_1736 = true;
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(1);
                                    }
                                    let __match = self.base.match_token_recovering(83, 1733, 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(84, 1735, atn())?;
                                    __consumed_eof |= __match.consumed_eof();
                                    for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                                }
                                2 => {
                                    if __ctx.context_alt_number() == 0 {
                                        __ctx.set_context_alt_number(2);
                                    }
                                    break;
                                }
                                _ => 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_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(1741isize);
                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);
                match self.base.sync_decision(atn(), 1743, !__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(), 1743) {
                    __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(216, 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(216, 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(), 1743, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1742isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __invoking_marker = self.base.push_invoking_state(1745isize);
                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);
                let __invoking_marker = self.base.push_invoking_state(1746isize);
                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);
            }
            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 {
                match self.base.sync_decision(atn(), 1751, !__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(), 1751) {
                    __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(217, 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(217, 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(), 1751, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(90, 1749, 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(89, 1752, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1750isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 {
                match self.base.sync_decision(atn(), 1756, !__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(), 1756) {
                    __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(218, 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(218, 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(), 1756, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(90, 1754, 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(89, 1757, atn())?;
                        __consumed_eof |= __match.consumed_eof();
                        for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1755isize);
                        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_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_recovering(90, 1759, 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(1759isize);
                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);
                let __match = self.base.match_token_recovering(89, 1761, 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 __invoking_marker = self.base.push_invoking_state(1762isize);
                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);
                let mut __loop_iter_1767 = false;
                loop {
                    match self.base.sync_decision(atn(), 1767, !__ctx.has_matched_child(), __loop_iter_1767) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        38 | 81 | 89 => 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(), 1767, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1767 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 1764, 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(1764isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 mut __loop_iter_1773 = false;
                loop {
                    match self.base.sync_decision(atn(), 1773, !__ctx.has_matched_child(), __loop_iter_1773) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        3 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1773, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1773 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __invoking_marker = self.base.push_invoking_state(1770isize);
                            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 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(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) {
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    3 | 5 | 8 | 14 | 21 | 28 | 30 | 47 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1778, !__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) {
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            3 | 5 | 8 | 14 | 21 | 28 | 30 | 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(), 1778, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1776isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1777isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_1790 = false;
                loop {
                    match self.base.sync_decision(atn(), 1790, !__ctx.has_matched_child(), __loop_iter_1790) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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(), 1790) {
                        __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(223, 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(223, 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(), 1790, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1790 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let mut __loop_iter_1783 = false;
                            loop {
                                match self.base.sync_decision(atn(), 1783, !__ctx.has_matched_child(), __loop_iter_1783) {
                                    Ok(__sync_children) => {
                                        for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                                    124 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    83 => 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(), 1783, &__prediction);
                                match __prediction.alt {
                                    1 => {
                                        __loop_iter_1783 = true;
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(1);
                                        }
                                        let __invoking_marker = self.base.push_invoking_state(1780isize);
                                        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 => {
                                        if __ctx.context_alt_number() == 0 {
                                            __ctx.set_context_alt_number(2);
                                        }
                                        break;
                                    }
                                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                                }
                            }
                            let __match = self.base.match_token_recovering(83, 1787, 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(84, 1789, atn())?;
                            __consumed_eof |= __match.consumed_eof();
                            for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => 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_set_recovering(&[(3, 3), (5, 5), (8, 8), (14, 14), (21, 21), (28, 28), (30, 30), (47, 47)], 1794, 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 {
                let __match = self.base.match_token_recovering(90, 1796, 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(1796isize);
                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);
                let mut __loop_iter_1801 = false;
                loop {
                    match self.base.sync_decision(atn(), 1801, !__ctx.has_matched_child(), __loop_iter_1801) {
                        Ok(__sync_children) => {
                            for __child in __sync_children { self.base.add_parse_child(&mut __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) {
                        86 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        89 => 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(), 1801, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_1801 = true;
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(1);
                            }
                            let __match = self.base.match_token_recovering(86, 1798, 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(1798isize);
                            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);
                        }
                        2 => {
                            if __ctx.context_alt_number() == 0 {
                                __ctx.set_context_alt_number(2);
                            }
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                let __match = self.base.match_token_recovering(89, 1805, 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_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 mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    79 => 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 },
                    _ => {
                        match self.base.sync_decision(atn(), 1815, !__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) {
                            79 => 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(), 1815, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1806isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __match = self.base.match_token_recovering(87, 1809, 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(), 1809, !__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) {
                            90 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1809, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1808isize);
                                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);
                            }
                            2 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(2);
                                }
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let __invoking_marker = self.base.push_invoking_state(1811isize);
                        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);
                        match self.base.sync_decision(atn(), 1813, !__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(), 1813) {
                            __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(226, 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(226, 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(), 1813, &__prediction);
                        match __prediction.alt {
                            1 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(1);
                                }
                                let __invoking_marker = self.base.push_invoking_state(1812isize);
                                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 => {
                                if __ctx.context_alt_number() == 0 {
                                    __ctx.set_context_alt_number(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_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 {
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        match self.base.sync_decision(atn(), 1822, !__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) {
                            50 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            17 | 31 | 35..=36 | 38 | 41 | 43..=44 | 46 | 56 | 58 | 60..=61 | 64 | 66..=67 | 129 => 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(), 1822, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __match = self.base.match_token_recovering(50, 1818, 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(1818isize);
                        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 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1819isize);
                        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);
                        let __invoking_marker = self.base.push_invoking_state(1820isize);
                        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);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 __match = self.base.match_token_recovering(79, 1826, 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(), 1826, !__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 | 5 | 8 | 14 | 17 | 21 | 28 | 30..=31 | 33 | 35..=36 | 38 | 41 | 43..=44 | 46..=47 | 50..=51 | 53 | 56 | 58 | 60..=62 | 64 | 66..=79 | 90..=92 | 101..=104 | 124 | 129 => 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(), 1826, &__prediction);
                match __prediction.alt {
                    1 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(1);
                        }
                        let __invoking_marker = self.base.push_invoking_state(1825isize);
                        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);
                    }
                    2 => {
                        if __ctx.context_alt_number() == 0 {
                            __ctx.set_context_alt_number(2);
                        }
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let __match = self.base.match_token_recovering(80, 1829, atn())?;
                __consumed_eof |= __match.consumed_eof();
                for __child in __match.into_child_iter() { self.base.add_parse_child(&mut __ctx, __child); }
            }
            success {}
            recovery {}
        }
    }



    pub fn compilation_unit(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(0)
    }
    pub fn modular_compulation_unit(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(1)
    }
    pub fn package_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(2)
    }
    pub fn import_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(3)
    }
    pub fn type_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(4)
    }
    pub fn modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(5)
    }
    pub fn class_or_interface_modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(6)
    }
    pub fn variable_modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(7)
    }
    pub fn class_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(8)
    }
    pub fn type_parameters(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(9)
    }
    pub fn type_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(10)
    }
    pub fn type_bound(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(11)
    }
    pub fn enum_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(12)
    }
    pub fn enum_constants(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(13)
    }
    pub fn enum_constant(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(14)
    }
    pub fn enum_body_declarations(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(15)
    }
    pub fn interface_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(16)
    }
    pub fn class_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(17)
    }
    pub fn interface_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(18)
    }
    pub fn class_body_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(19)
    }
    pub fn member_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(20)
    }
    pub fn method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(21)
    }
    pub fn method_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(22)
    }
    pub fn type_type_or_void(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(23)
    }
    pub fn generic_method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(24)
    }
    pub fn generic_constructor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(25)
    }
    pub fn constructor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(26)
    }
    pub fn compact_constructor_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(27)
    }
    pub fn field_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(28)
    }
    pub fn interface_body_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(29)
    }
    pub fn interface_member_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(30)
    }
    pub fn const_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(31)
    }
    pub fn constant_declarator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(32)
    }
    pub fn interface_method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(33)
    }
    pub fn interface_method_modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(34)
    }
    pub fn generic_interface_method_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(35)
    }
    pub fn interface_common_body_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(36)
    }
    pub fn variable_declarators(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(37)
    }
    pub fn variable_declarator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(38)
    }
    pub fn variable_declarator_id(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(39)
    }
    pub fn variable_initializer(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(40)
    }
    pub fn array_initializer(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(41)
    }
    pub fn class_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(42)
    }
    pub fn package_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(43)
    }
    pub fn type_argument(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(44)
    }
    pub fn qualified_name_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(45)
    }
    pub fn formal_parameters(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(46)
    }
    pub fn receiver_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(47)
    }
    pub fn formal_parameter_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(48)
    }
    pub fn formal_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(49)
    }
    pub fn lambda_lvti_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(50)
    }
    pub fn lambda_lvti_parameter(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(51)
    }
    pub fn qualified_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(52)
    }
    pub fn literal(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(53)
    }
    pub fn integer_literal(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(54)
    }
    pub fn float_literal(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(55)
    }
    pub fn annotation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(56)
    }
    pub fn annotation_field_values(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(57)
    }
    pub fn annotation_field_value(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(58)
    }
    pub fn annotation_value(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(59)
    }
    pub fn element_value(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(60)
    }
    pub fn element_value_array_initializer(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(61)
    }
    pub fn annotation_type_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(62)
    }
    pub fn annotation_type_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(63)
    }
    pub fn annotation_type_element_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(64)
    }
    pub fn annotation_type_element_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(65)
    }
    pub fn annotation_method_or_constant_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(66)
    }
    pub fn annotation_method_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(67)
    }
    pub fn annotation_constant_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(68)
    }
    pub fn default_value(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(69)
    }
    pub fn module_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(70)
    }
    pub fn module_directive(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(71)
    }
    pub fn requires_modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(72)
    }
    pub fn record_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(73)
    }
    pub fn record_header(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(74)
    }
    pub fn record_component_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(75)
    }
    pub fn record_component(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(76)
    }
    pub fn record_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(77)
    }
    pub fn block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(78)
    }
    pub fn block_statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(79)
    }
    pub fn local_variable_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(80)
    }
    pub fn identifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(81)
    }
    pub fn type_identifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(82)
    }
    pub fn local_type_declaration(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(83)
    }
    pub fn statement(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(84)
    }
    pub fn catch_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(85)
    }
    pub fn catch_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(86)
    }
    pub fn finally_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(87)
    }
    pub fn resource_specification(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(88)
    }
    pub fn resources(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(89)
    }
    pub fn resource(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(90)
    }
    pub fn switch_block_statement_group(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(91)
    }
    pub fn switch_label(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(92)
    }
    pub fn for_control(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(93)
    }
    pub fn for_init(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(94)
    }
    pub fn enhanced_for_control(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(95)
    }
    pub fn expression_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(96)
    }
    pub fn method_call(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(97)
    }
    pub fn expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(98)
    }
    pub fn pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(99)
    }
    pub fn component_pattern_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(100)
    }
    pub fn component_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(101)
    }
    pub fn lambda_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(102)
    }
    pub fn lambda_parameters(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(103)
    }
    pub fn lambda_body(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(104)
    }
    pub fn primary(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(105)
    }
    pub fn switch_expression(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(106)
    }
    pub fn switch_labeled_rule(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(107)
    }
    pub fn guard(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(108)
    }
    pub fn case_pattern(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(109)
    }
    pub fn switch_rule_outcome(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(110)
    }
    pub fn class_or_interface_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(111)
    }
    pub fn creator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(112)
    }
    pub fn created_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(113)
    }
    pub fn inner_creator(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(114)
    }
    pub fn array_creator_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(115)
    }
    pub fn class_creator_rest(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(116)
    }
    pub fn explicit_generic_invocation(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(117)
    }
    pub fn type_arguments_or_diamond(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(118)
    }
    pub fn non_wildcard_type_arguments_or_diamond(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(119)
    }
    pub fn non_wildcard_type_arguments(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(120)
    }
    pub fn type_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(121)
    }
    pub fn type_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(122)
    }
    pub fn primitive_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(123)
    }
    pub fn type_arguments(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(124)
    }
    pub fn super_suffix(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(125)
    }
    pub fn explicit_generic_invocation_suffix(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(126)
    }
    pub fn arguments(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(127)
    }


    fn run_action(&mut self, action: antlr4_runtime::ParserAction, tree: antlr4_runtime::ParseTree) {
        match action.source_state() {
            1410 => {}
            _ => { let _ = self.base.parser_action_hook(action, tree); }
        }
    }

}

impl<L, T> JavaParser<L, JavaParserTypedHooks<T>>
where
    L: TokenSource,
    T: JavaParserHooks,
{
    pub fn with_typed_hooks(input: CommonTokenStream<L>, hooks: T) -> Self {
        Self::with_hooks(input, JavaParserTypedHooks::new(hooks))
    }
}


antlr4_runtime::__antlr4_rust_parser_facade! {
    type: JavaParser<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::*;
