// @generated by antlr-rust-codegen v0.31.0 - do not edit
// project: https://github.com/ophi-dev/antlr-rust-runtime
antlr4_runtime::__antlr4_rust_require_codegen_api!(8, "0.31.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 ACTION: i32 = 4;
pub const ARG_ACTION: i32 = 5;
pub const ARG_OR_CHARSET: i32 = 6;
pub const ASSIGN: i32 = 7;
pub const LEXER_CHAR_SET: i32 = 8;
pub const RULE_REF: i32 = 9;
pub const SEMPRED: i32 = 10;
pub const STRING_LITERAL: i32 = 11;
pub const TOKEN_REF: i32 = 12;
pub const UNICODE_ESC: i32 = 13;
pub const UNICODE_EXTENDED_ESC: i32 = 14;
pub const WS: i32 = 15;
pub const ALT: i32 = 16;
pub const BLOCK: i32 = 17;
pub const CLOSURE: i32 = 18;
pub const ELEMENT_OPTIONS: i32 = 19;
pub const EPSILON: i32 = 20;
pub const LEXER_ACTION_CALL: i32 = 21;
pub const LEXER_ALT_ACTION: i32 = 22;
pub const OPTIONAL: i32 = 23;
pub const POSITIVE_CLOSURE: i32 = 24;
pub const RULE: i32 = 25;
pub const RULEMODIFIERS: i32 = 26;
pub const RULES: i32 = 27;
pub const SET: i32 = 28;
pub const WILDCARD: i32 = 29;
pub const DOC_COMMENT: i32 = 30;
pub const BLOCK_COMMENT: i32 = 31;
pub const LINE_COMMENT: i32 = 32;
pub const INT: i32 = 33;
pub const UNTERMINATED_STRING_LITERAL: i32 = 34;
pub const BEGIN_ARGUMENT: i32 = 35;
pub const OPTIONS: i32 = 36;
pub const TOKENS: i32 = 37;
pub const CHANNELS: i32 = 38;
pub const IMPORT: i32 = 39;
pub const FRAGMENT: i32 = 40;
pub const LEXER: i32 = 41;
pub const PARSER: i32 = 42;
pub const GRAMMAR: i32 = 43;
pub const PROTECTED: i32 = 44;
pub const PUBLIC: i32 = 45;
pub const PRIVATE: i32 = 46;
pub const RETURNS: i32 = 47;
pub const LOCALS: i32 = 48;
pub const THROWS: i32 = 49;
pub const CATCH: i32 = 50;
pub const FINALLY: i32 = 51;
pub const MODE: i32 = 52;
pub const COLON: i32 = 53;
pub const COLONCOLON: i32 = 54;
pub const COMMA: i32 = 55;
pub const SEMI: i32 = 56;
pub const LPAREN: i32 = 57;
pub const RPAREN: i32 = 58;
pub const RBRACE: i32 = 59;
pub const RARROW: i32 = 60;
pub const LT: i32 = 61;
pub const GT: i32 = 62;
pub const QUESTION: i32 = 63;
pub const STAR: i32 = 64;
pub const PLUS_ASSIGN: i32 = 65;
pub const PLUS: i32 = 66;
pub const OR: i32 = 67;
pub const DOLLAR: i32 = 68;
pub const RANGE: i32 = 69;
pub const DOT: i32 = 70;
pub const AT: i32 = 71;
pub const POUND: i32 = 72;
pub const NOT: i32 = 73;
pub const ID: i32 = 74;
pub const END_ARGUMENT: i32 = 75;
pub const UNTERMINATED_ARGUMENT: i32 = 76;
pub const ARGUMENT_CONTENT: i32 = 77;
pub const UNTERMINATED_CHAR_SET: i32 = 78;

pub const RULE_GRAMMAR_SPEC: usize = 0;
pub const RULE_GRAMMAR_DECL: usize = 1;
pub const RULE_GRAMMAR_TYPE: usize = 2;
pub const RULE_PREQUEL_CONSTRUCT: usize = 3;
pub const RULE_OPTIONS_SPEC: usize = 4;
pub const RULE_OPTION: usize = 5;
pub const RULE_OPTION_VALUE: usize = 6;
pub const RULE_DELEGATE_GRAMMARS: usize = 7;
pub const RULE_DELEGATE_GRAMMAR: usize = 8;
pub const RULE_TOKENS_SPEC: usize = 9;
pub const RULE_CHANNELS_SPEC: usize = 10;
pub const RULE_ID_LIST: usize = 11;
pub const RULE_ACTION: usize = 12;
pub const RULE_ACTION_SCOPE_NAME: usize = 13;
pub const RULE_ACTION_BLOCK: usize = 14;
pub const RULE_ARG_ACTION_BLOCK: usize = 15;
pub const RULE_MODE_SPEC: usize = 16;
pub const RULE_RULES: usize = 17;
pub const RULE_RULE_SPEC: usize = 18;
pub const RULE_PARSER_RULE_SPEC: usize = 19;
pub const RULE_EXCEPTION_GROUP: usize = 20;
pub const RULE_EXCEPTION_HANDLER: usize = 21;
pub const RULE_FINALLY_CLAUSE: usize = 22;
pub const RULE_RULE_PREQUEL: usize = 23;
pub const RULE_RULE_RETURNS: usize = 24;
pub const RULE_THROWS_SPEC: usize = 25;
pub const RULE_LOCALS_SPEC: usize = 26;
pub const RULE_RULE_ACTION: usize = 27;
pub const RULE_RULE_MODIFIERS: usize = 28;
pub const RULE_RULE_MODIFIER: usize = 29;
pub const RULE_RULE_BLOCK: usize = 30;
pub const RULE_RULE_ALT_LIST: usize = 31;
pub const RULE_LABELED_ALT: usize = 32;
pub const RULE_LEXER_RULE_SPEC: usize = 33;
pub const RULE_LEXER_RULE_BLOCK: usize = 34;
pub const RULE_LEXER_ALT_LIST: usize = 35;
pub const RULE_LEXER_ALT: usize = 36;
pub const RULE_LEXER_ELEMENTS: usize = 37;
pub const RULE_LEXER_ELEMENT: usize = 38;
pub const RULE_LEXER_BLOCK: usize = 39;
pub const RULE_LEXER_COMMANDS: usize = 40;
pub const RULE_LEXER_COMMAND: usize = 41;
pub const RULE_LEXER_COMMAND_NAME: usize = 42;
pub const RULE_LEXER_COMMAND_EXPR: usize = 43;
pub const RULE_ALT_LIST: usize = 44;
pub const RULE_ALTERNATIVE: usize = 45;
pub const RULE_ELEMENT: usize = 46;
pub const RULE_PREDICATE_OPTIONS: usize = 47;
pub const RULE_PREDICATE_OPTION: usize = 48;
pub const RULE_LABELED_ELEMENT: usize = 49;
pub const RULE_EBNF: usize = 50;
pub const RULE_BLOCK_SUFFIX: usize = 51;
pub const RULE_EBNF_SUFFIX: usize = 52;
pub const RULE_LEXER_ATOM: usize = 53;
pub const RULE_ATOM: usize = 54;
pub const RULE_WILDCARD: usize = 55;
pub const RULE_NOT_SET: usize = 56;
pub const RULE_BLOCK_SET: usize = 57;
pub const RULE_SET_ELEMENT: usize = 58;
pub const RULE_BLOCK: usize = 59;
pub const RULE_RULEREF: usize = 60;
pub const RULE_CHARACTER_RANGE: usize = 61;
pub const RULE_TERMINAL_DEF: usize = 62;
pub const RULE_ELEMENT_OPTIONS: usize = 63;
pub const RULE_ELEMENT_OPTION: usize = 64;
pub const RULE_IDENTIFIER: usize = 65;
pub const RULE_QUALIFIED_IDENTIFIER: usize = 66;

pub static METADATA: GrammarMetadata = GrammarMetadata::new(
    "ANTLRv4Parser",
    &["grammarSpec", "grammarDecl", "grammarType", "prequelConstruct", "optionsSpec", "option", "optionValue", "delegateGrammars", "delegateGrammar", "tokensSpec", "channelsSpec", "idList", "action_", "actionScopeName", "actionBlock", "argActionBlock", "modeSpec", "rules", "ruleSpec", "parserRuleSpec", "exceptionGroup", "exceptionHandler", "finallyClause", "rulePrequel", "ruleReturns", "throwsSpec", "localsSpec", "ruleAction", "ruleModifiers", "ruleModifier", "ruleBlock", "ruleAltList", "labeledAlt", "lexerRuleSpec", "lexerRuleBlock", "lexerAltList", "lexerAlt", "lexerElements", "lexerElement", "lexerBlock", "lexerCommands", "lexerCommand", "lexerCommandName", "lexerCommandExpr", "altList", "alternative", "element", "predicateOptions", "predicateOption", "labeledElement", "ebnf", "blockSuffix", "ebnfSuffix", "lexerAtom", "atom", "wildcard", "notSet", "blockSet", "setElement", "block", "ruleref", "characterRange", "terminalDef", "elementOptions", "elementOption", "identifier", "qualifiedIdentifier"],
    &[None, None, None, None, None, None, None, Some("\'=\'"), None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, Some("\'[\'"), None, None, None, Some("\'import\'"), Some("\'fragment\'"), Some("\'lexer\'"), Some("\'parser\'"), Some("\'grammar\'"), Some("\'protected\'"), Some("\'public\'"), Some("\'private\'"), Some("\'returns\'"), Some("\'locals\'"), Some("\'throws\'"), Some("\'catch\'"), Some("\'finally\'"), Some("\'mode\'"), 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],
    &[None, None, None, None, Some("ACTION"), Some("ARG_ACTION"), Some("ARG_OR_CHARSET"), Some("ASSIGN"), Some("LEXER_CHAR_SET"), Some("RULE_REF"), Some("SEMPRED"), Some("STRING_LITERAL"), Some("TOKEN_REF"), Some("UNICODE_ESC"), Some("UNICODE_EXTENDED_ESC"), Some("WS"), Some("ALT"), Some("BLOCK"), Some("CLOSURE"), Some("ELEMENT_OPTIONS"), Some("EPSILON"), Some("LEXER_ACTION_CALL"), Some("LEXER_ALT_ACTION"), Some("OPTIONAL"), Some("POSITIVE_CLOSURE"), Some("RULE"), Some("RULEMODIFIERS"), Some("RULES"), Some("SET"), Some("WILDCARD"), Some("DOC_COMMENT"), Some("BLOCK_COMMENT"), Some("LINE_COMMENT"), Some("INT"), Some("UNTERMINATED_STRING_LITERAL"), Some("BEGIN_ARGUMENT"), Some("OPTIONS"), Some("TOKENS"), Some("CHANNELS"), Some("IMPORT"), Some("FRAGMENT"), Some("LEXER"), Some("PARSER"), Some("GRAMMAR"), Some("PROTECTED"), Some("PUBLIC"), Some("PRIVATE"), Some("RETURNS"), Some("LOCALS"), Some("THROWS"), Some("CATCH"), Some("FINALLY"), Some("MODE"), Some("COLON"), Some("COLONCOLON"), Some("COMMA"), Some("SEMI"), Some("LPAREN"), Some("RPAREN"), Some("RBRACE"), Some("RARROW"), Some("LT"), Some("GT"), Some("QUESTION"), Some("STAR"), Some("PLUS_ASSIGN"), Some("PLUS"), Some("OR"), Some("DOLLAR"), Some("RANGE"), Some("DOT"), Some("AT"), Some("POUND"), Some("NOT"), Some("ID"), Some("END_ARGUMENT"), Some("UNTERMINATED_ARGUMENT"), Some("ARGUMENT_CONTENT"), Some("UNTERMINATED_CHAR_SET")],
    &[None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, 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 actions = Vec::new();
        antlr4_runtime::ParserSemantics { ir, predicates, actions }
    })
}




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(dead_code)]
trait __RecoveryContextState {}

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

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

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

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

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

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

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    GrammarSpecContext {
        rule grammar_decl: required(GrammarDeclContext[1], "grammarDecl"),
        rule prequel_construct_children: many(PrequelConstructContext[3]),
        rule mode_spec_children: many(ModeSpecContext[16]),
        rule rules: required(RulesContext[17], "rules"),
        token eof_token: required(-1, "EOF"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    GrammarDeclContext {
        rule grammar_type: required(GrammarTypeContext[2], "grammarType"),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token semi_token: required(56, "SEMI"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    GrammarTypeContext {
        token lexer_token: optional(41),
        token parser_token: optional(42),
        token grammar_token: required(43, "GRAMMAR"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    PrequelConstructContext {
        rule options_spec: optional(OptionsSpecContext[4]),
        rule delegate_grammars: optional(DelegateGrammarsContext[7]),
        rule tokens_spec: optional(TokensSpecContext[9]),
        rule channels_spec: optional(ChannelsSpecContext[10]),
        rule action: optional(ActionContext[12]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    OptionsSpecContext {
        rule option_children: many(OptionContext[5]),
        token options_token: required(36, "OPTIONS"),
        token semi_tokens: many(56),
        token rbrace_token: required(59, "RBRACE"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    OptionContext {
        rule option_value: required(OptionValueContext[6], "optionValue"),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token assign_token: required(7, "ASSIGN"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    OptionValueContext {
        rule action_block: optional(ActionBlockContext[14]),
        rule identifier_children: many(IdentifierContext[65]),
        token string_literal_token: optional(11),
        token int_token: optional(33),
        token dot_tokens: many(70),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    DelegateGrammarsContext {
        rule delegate_grammar_children: many(DelegateGrammarContext[8]),
        token import_token: required(39, "IMPORT"),
        token comma_tokens: many(55),
        token semi_token: required(56, "SEMI"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    DelegateGrammarContext {
        rule identifier_children: many(IdentifierContext[65]),
        token assign_token: optional(7),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    TokensSpecContext {
        rule id_list: optional(IdListContext[11]),
        token tokens_token: required(37, "TOKENS"),
        token rbrace_token: required(59, "RBRACE"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ChannelsSpecContext {
        rule id_list: optional(IdListContext[11]),
        token channels_token: required(38, "CHANNELS"),
        token rbrace_token: required(59, "RBRACE"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    IdListContext {
        rule identifier_children: many(IdentifierContext[65]),
        token comma_tokens: many(55),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ActionContext {
        rule action_scope_name: optional(ActionScopeNameContext[13]),
        rule action_block: required(ActionBlockContext[14], "actionBlock"),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token coloncolon_token: optional(54),
        token at_token: required(71, "AT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ActionScopeNameContext {
        rule identifier: optional(IdentifierContext[65]),
        token lexer_token: optional(41),
        token parser_token: optional(42),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ActionBlockContext {
        token action_token: required(4, "ACTION"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ArgActionBlockContext {
        token begin_argument_token: required(35, "BEGIN_ARGUMENT"),
        token end_argument_token: required(75, "END_ARGUMENT"),
        token argument_content_tokens: many(77),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ModeSpecContext {
        rule lexer_rule_spec_children: many(LexerRuleSpecContext[33]),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token mode_token: required(52, "MODE"),
        token semi_token: required(56, "SEMI"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RulesContext {
        rule rule_spec_children: many(RuleSpecContext[18]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleSpecContext {
        rule parser_rule_spec: optional(ParserRuleSpecContext[19]),
        rule lexer_rule_spec: optional(LexerRuleSpecContext[33]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ParserRuleSpecContext {
        rule arg_action_block: optional(ArgActionBlockContext[15]),
        rule exception_group: required(ExceptionGroupContext[20], "exceptionGroup"),
        rule rule_prequel_children: many(RulePrequelContext[23]),
        rule rule_returns: optional(RuleReturnsContext[24]),
        rule throws_spec: optional(ThrowsSpecContext[25]),
        rule locals_spec: optional(LocalsSpecContext[26]),
        rule rule_modifiers: optional(RuleModifiersContext[28]),
        rule rule_block: required(RuleBlockContext[30], "ruleBlock"),
        token rule_ref_token: required(9, "RULE_REF"),
        token colon_token: required(53, "COLON"),
        token semi_token: required(56, "SEMI"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ExceptionGroupContext {
        rule exception_handler_children: many(ExceptionHandlerContext[21]),
        rule finally_clause: optional(FinallyClauseContext[22]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ExceptionHandlerContext {
        rule action_block: required(ActionBlockContext[14], "actionBlock"),
        rule arg_action_block: required(ArgActionBlockContext[15], "argActionBlock"),
        token catch_token: required(50, "CATCH"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    FinallyClauseContext {
        rule action_block: required(ActionBlockContext[14], "actionBlock"),
        token finally_token: required(51, "FINALLY"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RulePrequelContext {
        rule options_spec: optional(OptionsSpecContext[4]),
        rule rule_action: optional(RuleActionContext[27]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleReturnsContext {
        rule arg_action_block: required(ArgActionBlockContext[15], "argActionBlock"),
        token returns_token: required(47, "RETURNS"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ThrowsSpecContext {
        rule qualified_identifier_children: many(QualifiedIdentifierContext[66]),
        token throws_token: required(49, "THROWS"),
        token comma_tokens: many(55),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LocalsSpecContext {
        rule arg_action_block: required(ArgActionBlockContext[15], "argActionBlock"),
        token locals_token: required(48, "LOCALS"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleActionContext {
        rule action_block: required(ActionBlockContext[14], "actionBlock"),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token at_token: required(71, "AT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleModifiersContext {
        rule rule_modifier_children: many(RuleModifierContext[29]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleModifierContext {
        token fragment_token: optional(40),
        token protected_token: optional(44),
        token public_token: optional(45),
        token private_token: optional(46),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleBlockContext {
        rule rule_alt_list: required(RuleAltListContext[31], "ruleAltList"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RuleAltListContext {
        rule labeled_alt_children: many(LabeledAltContext[32]),
        token or_tokens: many(67),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LabeledAltContext {
        rule alternative: required(AlternativeContext[45], "alternative"),
        rule identifier: optional(IdentifierContext[65]),
        token pound_token: optional(72),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerRuleSpecContext {
        rule options_spec: optional(OptionsSpecContext[4]),
        rule lexer_rule_block: required(LexerRuleBlockContext[34], "lexerRuleBlock"),
        token token_ref_token: required(12, "TOKEN_REF"),
        token fragment_token: optional(40),
        token colon_token: required(53, "COLON"),
        token semi_token: required(56, "SEMI"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerRuleBlockContext {
        rule lexer_alt_list: required(LexerAltListContext[35], "lexerAltList"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerAltListContext {
        rule lexer_alt_children: many(LexerAltContext[36]),
        token or_tokens: many(67),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerAltContext {
        rule lexer_elements: optional(LexerElementsContext[37]),
        rule lexer_commands: optional(LexerCommandsContext[40]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerElementsContext {
        rule lexer_element_children: many(LexerElementContext[38]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerElementContext {
        rule action_block: optional(ActionBlockContext[14]),
        rule lexer_block: optional(LexerBlockContext[39]),
        rule ebnf_suffix: optional(EbnfSuffixContext[52]),
        rule lexer_atom: optional(LexerAtomContext[53]),
        token question_token: optional(63),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerBlockContext {
        rule lexer_alt_list: required(LexerAltListContext[35], "lexerAltList"),
        token lparen_token: required(57, "LPAREN"),
        token rparen_token: required(58, "RPAREN"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerCommandsContext {
        rule lexer_command_children: many(LexerCommandContext[41]),
        token comma_tokens: many(55),
        token rarrow_token: required(60, "RARROW"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerCommandContext {
        rule lexer_command_name: required(LexerCommandNameContext[42], "lexerCommandName"),
        rule lexer_command_expr: optional(LexerCommandExprContext[43]),
        token lparen_token: optional(57),
        token rparen_token: optional(58),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerCommandNameContext {
        rule identifier: optional(IdentifierContext[65]),
        token mode_token: optional(52),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerCommandExprContext {
        rule identifier: optional(IdentifierContext[65]),
        token int_token: optional(33),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    AltListContext {
        rule alternative_children: many(AlternativeContext[45]),
        token or_tokens: many(67),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    AlternativeContext {
        rule element_children: many(ElementContext[46]),
        rule element_options: optional(ElementOptionsContext[63]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ElementContext {
        rule action_block: optional(ActionBlockContext[14]),
        rule predicate_options: optional(PredicateOptionsContext[47]),
        rule labeled_element: optional(LabeledElementContext[49]),
        rule ebnf: optional(EbnfContext[50]),
        rule ebnf_suffix: optional(EbnfSuffixContext[52]),
        rule atom: optional(AtomContext[54]),
        token question_token: optional(63),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    PredicateOptionsContext {
        rule predicate_option_children: many(PredicateOptionContext[48]),
        token comma_tokens: many(55),
        token lt_token: required(61, "LT"),
        token gt_token: required(62, "GT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    PredicateOptionContext {
        rule action_block: optional(ActionBlockContext[14]),
        rule element_option: optional(ElementOptionContext[64]),
        rule identifier: optional(IdentifierContext[65]),
        token assign_token: optional(7),
        token string_literal_token: optional(11),
        token int_token: optional(33),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LabeledElementContext {
        rule atom: optional(AtomContext[54]),
        rule block: optional(BlockContext[59]),
        rule identifier: required(IdentifierContext[65], "identifier"),
        token assign_token: optional(7),
        token plus_assign_token: optional(65),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    EbnfContext {
        rule block_suffix: optional(BlockSuffixContext[51]),
        rule block: required(BlockContext[59], "block"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    BlockSuffixContext {
        rule ebnf_suffix: required(EbnfSuffixContext[52], "ebnfSuffix"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    EbnfSuffixContext {
        token question_tokens: many(63),
        token star_token: optional(64),
        token plus_token: optional(66),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    LexerAtomContext {
        rule wildcard: optional(WildcardContext[55]),
        rule not_set: optional(NotSetContext[56]),
        rule character_range: optional(CharacterRangeContext[61]),
        rule terminal_def: optional(TerminalDefContext[62]),
        token lexer_char_set_token: optional(8),
        token rule_ref_token: optional(9),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    AtomContext {
        rule wildcard: optional(WildcardContext[55]),
        rule not_set: optional(NotSetContext[56]),
        rule ruleref: optional(RulerefContext[60]),
        rule terminal_def: optional(TerminalDefContext[62]),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    WildcardContext {
        rule element_options: optional(ElementOptionsContext[63]),
        token dot_token: required(70, "DOT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    NotSetContext {
        rule block_set: optional(BlockSetContext[57]),
        rule set_element: optional(SetElementContext[58]),
        token not_token: required(73, "NOT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    BlockSetContext {
        rule set_element_children: many(SetElementContext[58]),
        token lparen_token: required(57, "LPAREN"),
        token rparen_token: required(58, "RPAREN"),
        token or_tokens: many(67),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    SetElementContext {
        rule character_range: optional(CharacterRangeContext[61]),
        rule element_options: optional(ElementOptionsContext[63]),
        token lexer_char_set_token: optional(8),
        token string_literal_token: optional(11),
        token token_ref_token: optional(12),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    BlockContext {
        rule options_spec: optional(OptionsSpecContext[4]),
        rule rule_action_children: many(RuleActionContext[27]),
        rule alt_list: required(AltListContext[44], "altList"),
        token colon_token: optional(53),
        token lparen_token: required(57, "LPAREN"),
        token rparen_token: required(58, "RPAREN"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    RulerefContext {
        rule arg_action_block: optional(ArgActionBlockContext[15]),
        rule element_options: optional(ElementOptionsContext[63]),
        token rule_ref_token: required(9, "RULE_REF"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    CharacterRangeContext {
        token string_literal_tokens: many(11),
        token range_token: required(69, "RANGE"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    TerminalDefContext {
        rule element_options: optional(ElementOptionsContext[63]),
        token string_literal_token: optional(11),
        token token_ref_token: optional(12),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ElementOptionsContext {
        rule element_option_children: many(ElementOptionContext[64]),
        token comma_tokens: many(55),
        token lt_token: required(61, "LT"),
        token gt_token: required(62, "GT"),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    ElementOptionContext {
        rule identifier: optional(IdentifierContext[65]),
        rule qualified_identifier: optional(QualifiedIdentifierContext[66]),
        token assign_token: optional(7),
        token string_literal_token: optional(11),
        token int_token: optional(33),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    IdentifierContext {
        token rule_ref_token: optional(9),
        token token_ref_token: optional(12),
    }
}

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

antlr4_runtime::__antlr4_rust_context_accessors! {
    QualifiedIdentifierContext {
        rule identifier_children: many(IdentifierContext[65]),
        token dot_tokens: many(70),
    }
}

/// 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<(), ANTLRv4ValidationError> {
    let tree = parsed.tree();
    if tree.as_rule().is_none() {
        return Err(ANTLRv4ValidationError::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(ANTLRv4ValidationError::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 = GrammarSpecContext::__from_listener_node(context, None);
        let _ = context.grammar_decl().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rules().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.eof_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                1 => {
                    let context = GrammarDeclContext::__from_listener_node(context, None);
        let _ = context.grammar_type().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                2 => {
                    let context = GrammarTypeContext::__from_listener_node(context, None);
        let _ = context.grammar_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                3 => {
                },
                4 => {
                    let context = OptionsSpecContext::__from_listener_node(context, None);
        let _ = context.options_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                5 => {
                    let context = OptionContext::__from_listener_node(context, None);
        let _ = context.option_value().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.assign_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                6 => {
                },
                7 => {
                    let context = DelegateGrammarsContext::__from_listener_node(context, None);
        {
            let actual = context.delegate_grammar_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "DelegateGrammarsContext",
                    child: "delegateGrammar",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.import_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                8 => {
                    let context = DelegateGrammarContext::__from_listener_node(context, None);
        {
            let actual = context.identifier_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "DelegateGrammarContext",
                    child: "identifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                9 => {
                    let context = TokensSpecContext::__from_listener_node(context, None);
        let _ = context.tokens_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                10 => {
                    let context = ChannelsSpecContext::__from_listener_node(context, None);
        let _ = context.channels_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rbrace_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                11 => {
                    let context = IdListContext::__from_listener_node(context, None);
        {
            let actual = context.identifier_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "IdListContext",
                    child: "identifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                12 => {
                    let context = ActionContext::__from_listener_node(context, None);
        let _ = context.action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.at_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                13 => {
                },
                14 => {
                    let context = ActionBlockContext::__from_listener_node(context, None);
        let _ = context.action_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                15 => {
                    let context = ArgActionBlockContext::__from_listener_node(context, None);
        let _ = context.begin_argument_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.end_argument_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                16 => {
                    let context = ModeSpecContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.mode_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                17 => {
                },
                18 => {
                },
                19 => {
                    let context = ParserRuleSpecContext::__from_listener_node(context, None);
        let _ = context.exception_group().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rule_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rule_ref_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                20 => {
                },
                21 => {
                    let context = ExceptionHandlerContext::__from_listener_node(context, None);
        let _ = context.action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.arg_action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.catch_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                22 => {
                    let context = FinallyClauseContext::__from_listener_node(context, None);
        let _ = context.action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.finally_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                23 => {
                },
                24 => {
                    let context = RuleReturnsContext::__from_listener_node(context, None);
        let _ = context.arg_action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.returns_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                25 => {
                    let context = ThrowsSpecContext::__from_listener_node(context, None);
        {
            let actual = context.qualified_identifier_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "ThrowsSpecContext",
                    child: "qualifiedIdentifier",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.throws_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                26 => {
                    let context = LocalsSpecContext::__from_listener_node(context, None);
        let _ = context.arg_action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.locals_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                27 => {
                    let context = RuleActionContext::__from_listener_node(context, None);
        let _ = context.action_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.at_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                28 => {
                    let context = RuleModifiersContext::__from_listener_node(context, None);
        {
            let actual = context.rule_modifier_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "RuleModifiersContext",
                    child: "ruleModifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                29 => {
                },
                30 => {
                    let context = RuleBlockContext::__from_listener_node(context, None);
        let _ = context.rule_alt_list().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                31 => {
                    let context = RuleAltListContext::__from_listener_node(context, None);
        {
            let actual = context.labeled_alt_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "RuleAltListContext",
                    child: "labeledAlt",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                32 => {
                    let context = LabeledAltContext::__from_listener_node(context, None);
        let _ = context.alternative().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                33 => {
                    let context = LexerRuleSpecContext::__from_listener_node(context, None);
        let _ = context.lexer_rule_block().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.token_ref_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.colon_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.semi_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                34 => {
                    let context = LexerRuleBlockContext::__from_listener_node(context, None);
        let _ = context.lexer_alt_list().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                35 => {
                    let context = LexerAltListContext::__from_listener_node(context, None);
        {
            let actual = context.lexer_alt_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "LexerAltListContext",
                    child: "lexerAlt",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                36 => {
                },
                37 => {
                },
                38 => {
                },
                39 => {
                    let context = LexerBlockContext::__from_listener_node(context, None);
        let _ = context.lexer_alt_list().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                40 => {
                    let context = LexerCommandsContext::__from_listener_node(context, None);
        {
            let actual = context.lexer_command_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "LexerCommandsContext",
                    child: "lexerCommand",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.rarrow_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                41 => {
                    let context = LexerCommandContext::__from_listener_node(context, None);
        let _ = context.lexer_command_name().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                42 => {
                },
                43 => {
                },
                44 => {
                    let context = AltListContext::__from_listener_node(context, None);
        {
            let actual = context.alternative_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "AltListContext",
                    child: "alternative",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                45 => {
                },
                46 => {
                },
                47 => {
                    let context = PredicateOptionsContext::__from_listener_node(context, None);
        {
            let actual = context.predicate_option_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "PredicateOptionsContext",
                    child: "predicateOption",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lt_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                48 => {
                },
                49 => {
                    let context = LabeledElementContext::__from_listener_node(context, None);
        let _ = context.identifier().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                50 => {
                    let context = EbnfContext::__from_listener_node(context, None);
        let _ = context.block().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                51 => {
                    let context = BlockSuffixContext::__from_listener_node(context, None);
        let _ = context.ebnf_suffix().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                52 => {
                },
                53 => {
                },
                54 => {
                },
                55 => {
                    let context = WildcardContext::__from_listener_node(context, None);
        let _ = context.dot_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                56 => {
                    let context = NotSetContext::__from_listener_node(context, None);
        let _ = context.not_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                57 => {
                    let context = BlockSetContext::__from_listener_node(context, None);
        {
            let actual = context.set_element_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "BlockSetContext",
                    child: "setElement",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                58 => {
                },
                59 => {
                    let context = BlockContext::__from_listener_node(context, None);
        let _ = context.alt_list().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.lparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.rparen_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                60 => {
                    let context = RulerefContext::__from_listener_node(context, None);
        let _ = context.rule_ref_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                61 => {
                    let context = CharacterRangeContext::__from_listener_node(context, None);
        {
            let actual = context.string_literal_tokens().count();
            if actual < 2 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "CharacterRangeContext",
                    child: "STRING_LITERAL",
                    minimum: 2,
                    actual,
                });
            }
        }
        let _ = context.range_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                62 => {
                },
                63 => {
                    let context = ElementOptionsContext::__from_listener_node(context, None);
        {
            let actual = context.element_option_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "ElementOptionsContext",
                    child: "elementOption",
                    minimum: 1,
                    actual,
                });
            }
        }
        let _ = context.lt_token().map_err(ANTLRv4ValidationError::MissingChild)?;
        let _ = context.gt_token().map_err(ANTLRv4ValidationError::MissingChild)?;
                },
                64 => {
                },
                65 => {
                },
                66 => {
                    let context = QualifiedIdentifierContext::__from_listener_node(context, None);
        {
            let actual = context.identifier_children().count();
            if actual < 1 {
                return Err(ANTLRv4ValidationError::InvalidChildCount {
                    context: "QualifiedIdentifierContext",
                    child: "identifier",
                    minimum: 1,
                    actual,
                });
            }
        }
                },
                    _ => {
                        return Err(ANTLRv4ValidationError::UnknownRule {
                            rule_index: context.rule_index(),
                        });
                    }
                }
            }
        }
    }
    Ok(())
}

#[allow(dead_code, unused_variables)]
pub trait ANTLRv4Listener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: antlr4_runtime::Node<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        ANTLRv4TreeWalker::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_grammar_spec(&mut self, _ctx: &GrammarSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_grammar_spec(&mut self, _ctx: &GrammarSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_grammar_decl(&mut self, _ctx: &GrammarDeclContext) -> Result<(), E> { Ok(()) }
    fn exit_grammar_decl(&mut self, _ctx: &GrammarDeclContext) -> Result<(), E> { Ok(()) }
    fn enter_grammar_type(&mut self, _ctx: &GrammarTypeContext) -> Result<(), E> { Ok(()) }
    fn exit_grammar_type(&mut self, _ctx: &GrammarTypeContext) -> Result<(), E> { Ok(()) }
    fn enter_prequel_construct(&mut self, _ctx: &PrequelConstructContext) -> Result<(), E> { Ok(()) }
    fn exit_prequel_construct(&mut self, _ctx: &PrequelConstructContext) -> Result<(), E> { Ok(()) }
    fn enter_options_spec(&mut self, _ctx: &OptionsSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_options_spec(&mut self, _ctx: &OptionsSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_option(&mut self, _ctx: &OptionContext) -> Result<(), E> { Ok(()) }
    fn exit_option(&mut self, _ctx: &OptionContext) -> Result<(), E> { Ok(()) }
    fn enter_option_value(&mut self, _ctx: &OptionValueContext) -> Result<(), E> { Ok(()) }
    fn exit_option_value(&mut self, _ctx: &OptionValueContext) -> Result<(), E> { Ok(()) }
    fn enter_delegate_grammars(&mut self, _ctx: &DelegateGrammarsContext) -> Result<(), E> { Ok(()) }
    fn exit_delegate_grammars(&mut self, _ctx: &DelegateGrammarsContext) -> Result<(), E> { Ok(()) }
    fn enter_delegate_grammar(&mut self, _ctx: &DelegateGrammarContext) -> Result<(), E> { Ok(()) }
    fn exit_delegate_grammar(&mut self, _ctx: &DelegateGrammarContext) -> Result<(), E> { Ok(()) }
    fn enter_tokens_spec(&mut self, _ctx: &TokensSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_tokens_spec(&mut self, _ctx: &TokensSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_channels_spec(&mut self, _ctx: &ChannelsSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_channels_spec(&mut self, _ctx: &ChannelsSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_id_list(&mut self, _ctx: &IdListContext) -> Result<(), E> { Ok(()) }
    fn exit_id_list(&mut self, _ctx: &IdListContext) -> Result<(), E> { Ok(()) }
    fn enter_action(&mut self, _ctx: &ActionContext) -> Result<(), E> { Ok(()) }
    fn exit_action(&mut self, _ctx: &ActionContext) -> Result<(), E> { Ok(()) }
    fn enter_action_scope_name(&mut self, _ctx: &ActionScopeNameContext) -> Result<(), E> { Ok(()) }
    fn exit_action_scope_name(&mut self, _ctx: &ActionScopeNameContext) -> Result<(), E> { Ok(()) }
    fn enter_action_block(&mut self, _ctx: &ActionBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_action_block(&mut self, _ctx: &ActionBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_arg_action_block(&mut self, _ctx: &ArgActionBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_arg_action_block(&mut self, _ctx: &ArgActionBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_mode_spec(&mut self, _ctx: &ModeSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_mode_spec(&mut self, _ctx: &ModeSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_rules(&mut self, _ctx: &RulesContext) -> Result<(), E> { Ok(()) }
    fn exit_rules(&mut self, _ctx: &RulesContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_spec(&mut self, _ctx: &RuleSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_spec(&mut self, _ctx: &RuleSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_parser_rule_spec(&mut self, _ctx: &ParserRuleSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_parser_rule_spec(&mut self, _ctx: &ParserRuleSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_exception_group(&mut self, _ctx: &ExceptionGroupContext) -> Result<(), E> { Ok(()) }
    fn exit_exception_group(&mut self, _ctx: &ExceptionGroupContext) -> Result<(), E> { Ok(()) }
    fn enter_exception_handler(&mut self, _ctx: &ExceptionHandlerContext) -> Result<(), E> { Ok(()) }
    fn exit_exception_handler(&mut self, _ctx: &ExceptionHandlerContext) -> Result<(), E> { Ok(()) }
    fn enter_finally_clause(&mut self, _ctx: &FinallyClauseContext) -> Result<(), E> { Ok(()) }
    fn exit_finally_clause(&mut self, _ctx: &FinallyClauseContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_prequel(&mut self, _ctx: &RulePrequelContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_prequel(&mut self, _ctx: &RulePrequelContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_returns(&mut self, _ctx: &RuleReturnsContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_returns(&mut self, _ctx: &RuleReturnsContext) -> Result<(), E> { Ok(()) }
    fn enter_throws_spec(&mut self, _ctx: &ThrowsSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_throws_spec(&mut self, _ctx: &ThrowsSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_locals_spec(&mut self, _ctx: &LocalsSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_locals_spec(&mut self, _ctx: &LocalsSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_action(&mut self, _ctx: &RuleActionContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_action(&mut self, _ctx: &RuleActionContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_modifiers(&mut self, _ctx: &RuleModifiersContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_modifiers(&mut self, _ctx: &RuleModifiersContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_modifier(&mut self, _ctx: &RuleModifierContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_modifier(&mut self, _ctx: &RuleModifierContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_block(&mut self, _ctx: &RuleBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_block(&mut self, _ctx: &RuleBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_rule_alt_list(&mut self, _ctx: &RuleAltListContext) -> Result<(), E> { Ok(()) }
    fn exit_rule_alt_list(&mut self, _ctx: &RuleAltListContext) -> Result<(), E> { Ok(()) }
    fn enter_labeled_alt(&mut self, _ctx: &LabeledAltContext) -> Result<(), E> { Ok(()) }
    fn exit_labeled_alt(&mut self, _ctx: &LabeledAltContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_rule_spec(&mut self, _ctx: &LexerRuleSpecContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_rule_spec(&mut self, _ctx: &LexerRuleSpecContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_rule_block(&mut self, _ctx: &LexerRuleBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_rule_block(&mut self, _ctx: &LexerRuleBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_alt_list(&mut self, _ctx: &LexerAltListContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_alt_list(&mut self, _ctx: &LexerAltListContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_alt(&mut self, _ctx: &LexerAltContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_alt(&mut self, _ctx: &LexerAltContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_elements(&mut self, _ctx: &LexerElementsContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_elements(&mut self, _ctx: &LexerElementsContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_element(&mut self, _ctx: &LexerElementContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_element(&mut self, _ctx: &LexerElementContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_block(&mut self, _ctx: &LexerBlockContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_block(&mut self, _ctx: &LexerBlockContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_commands(&mut self, _ctx: &LexerCommandsContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_commands(&mut self, _ctx: &LexerCommandsContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command(&mut self, _ctx: &LexerCommandContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command(&mut self, _ctx: &LexerCommandContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command_name(&mut self, _ctx: &LexerCommandNameContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command_name(&mut self, _ctx: &LexerCommandNameContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command_expr(&mut self, _ctx: &LexerCommandExprContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command_expr(&mut self, _ctx: &LexerCommandExprContext) -> Result<(), E> { Ok(()) }
    fn enter_alt_list(&mut self, _ctx: &AltListContext) -> Result<(), E> { Ok(()) }
    fn exit_alt_list(&mut self, _ctx: &AltListContext) -> Result<(), E> { Ok(()) }
    fn enter_alternative(&mut self, _ctx: &AlternativeContext) -> Result<(), E> { Ok(()) }
    fn exit_alternative(&mut self, _ctx: &AlternativeContext) -> Result<(), E> { Ok(()) }
    fn enter_element(&mut self, _ctx: &ElementContext) -> Result<(), E> { Ok(()) }
    fn exit_element(&mut self, _ctx: &ElementContext) -> Result<(), E> { Ok(()) }
    fn enter_predicate_options(&mut self, _ctx: &PredicateOptionsContext) -> Result<(), E> { Ok(()) }
    fn exit_predicate_options(&mut self, _ctx: &PredicateOptionsContext) -> Result<(), E> { Ok(()) }
    fn enter_predicate_option(&mut self, _ctx: &PredicateOptionContext) -> Result<(), E> { Ok(()) }
    fn exit_predicate_option(&mut self, _ctx: &PredicateOptionContext) -> Result<(), E> { Ok(()) }
    fn enter_labeled_element(&mut self, _ctx: &LabeledElementContext) -> Result<(), E> { Ok(()) }
    fn exit_labeled_element(&mut self, _ctx: &LabeledElementContext) -> Result<(), E> { Ok(()) }
    fn enter_ebnf(&mut self, _ctx: &EbnfContext) -> Result<(), E> { Ok(()) }
    fn exit_ebnf(&mut self, _ctx: &EbnfContext) -> Result<(), E> { Ok(()) }
    fn enter_block_suffix(&mut self, _ctx: &BlockSuffixContext) -> Result<(), E> { Ok(()) }
    fn exit_block_suffix(&mut self, _ctx: &BlockSuffixContext) -> Result<(), E> { Ok(()) }
    fn enter_ebnf_suffix(&mut self, _ctx: &EbnfSuffixContext) -> Result<(), E> { Ok(()) }
    fn exit_ebnf_suffix(&mut self, _ctx: &EbnfSuffixContext) -> Result<(), E> { Ok(()) }
    fn enter_lexer_atom(&mut self, _ctx: &LexerAtomContext) -> Result<(), E> { Ok(()) }
    fn exit_lexer_atom(&mut self, _ctx: &LexerAtomContext) -> Result<(), E> { Ok(()) }
    fn enter_atom(&mut self, _ctx: &AtomContext) -> Result<(), E> { Ok(()) }
    fn exit_atom(&mut self, _ctx: &AtomContext) -> Result<(), E> { Ok(()) }
    fn enter_wildcard(&mut self, _ctx: &WildcardContext) -> Result<(), E> { Ok(()) }
    fn exit_wildcard(&mut self, _ctx: &WildcardContext) -> Result<(), E> { Ok(()) }
    fn enter_not_set(&mut self, _ctx: &NotSetContext) -> Result<(), E> { Ok(()) }
    fn exit_not_set(&mut self, _ctx: &NotSetContext) -> Result<(), E> { Ok(()) }
    fn enter_block_set(&mut self, _ctx: &BlockSetContext) -> Result<(), E> { Ok(()) }
    fn exit_block_set(&mut self, _ctx: &BlockSetContext) -> Result<(), E> { Ok(()) }
    fn enter_set_element(&mut self, _ctx: &SetElementContext) -> Result<(), E> { Ok(()) }
    fn exit_set_element(&mut self, _ctx: &SetElementContext) -> 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_ruleref(&mut self, _ctx: &RulerefContext) -> Result<(), E> { Ok(()) }
    fn exit_ruleref(&mut self, _ctx: &RulerefContext) -> Result<(), E> { Ok(()) }
    fn enter_character_range(&mut self, _ctx: &CharacterRangeContext) -> Result<(), E> { Ok(()) }
    fn exit_character_range(&mut self, _ctx: &CharacterRangeContext) -> Result<(), E> { Ok(()) }
    fn enter_terminal_def(&mut self, _ctx: &TerminalDefContext) -> Result<(), E> { Ok(()) }
    fn exit_terminal_def(&mut self, _ctx: &TerminalDefContext) -> Result<(), E> { Ok(()) }
    fn enter_element_options(&mut self, _ctx: &ElementOptionsContext) -> Result<(), E> { Ok(()) }
    fn exit_element_options(&mut self, _ctx: &ElementOptionsContext) -> Result<(), E> { Ok(()) }
    fn enter_element_option(&mut self, _ctx: &ElementOptionContext) -> Result<(), E> { Ok(()) }
    fn exit_element_option(&mut self, _ctx: &ElementOptionContext) -> 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_qualified_identifier(&mut self, _ctx: &QualifiedIdentifierContext) -> Result<(), E> { Ok(()) }
    fn exit_qualified_identifier(&mut self, _ctx: &QualifiedIdentifierContext) -> 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 ANTLRv4TreeWalker;

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

    pub fn walk_with_invocation_states<E, T: ANTLRv4Listener<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: ANTLRv4Listener<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_grammar_spec(&GrammarSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        1 => listener.enter_grammar_decl(&GrammarDeclContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_grammar_type(&GrammarTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_prequel_construct(&PrequelConstructContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_options_spec(&OptionsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_option(&OptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_option_value(&OptionValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_delegate_grammars(&DelegateGrammarsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_delegate_grammar(&DelegateGrammarContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_tokens_spec(&TokensSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_channels_spec(&ChannelsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_id_list(&IdListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_action(&ActionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_action_scope_name(&ActionScopeNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_action_block(&ActionBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_arg_action_block(&ArgActionBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_mode_spec(&ModeSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_rules(&RulesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_rule_spec(&RuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_parser_rule_spec(&ParserRuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_exception_group(&ExceptionGroupContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_exception_handler(&ExceptionHandlerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_finally_clause(&FinallyClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_rule_prequel(&RulePrequelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_rule_returns(&RuleReturnsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_throws_spec(&ThrowsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_locals_spec(&LocalsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_rule_action(&RuleActionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_rule_modifiers(&RuleModifiersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_rule_modifier(&RuleModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_rule_block(&RuleBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_rule_alt_list(&RuleAltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_labeled_alt(&LabeledAltContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_lexer_rule_spec(&LexerRuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_lexer_rule_block(&LexerRuleBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_lexer_alt_list(&LexerAltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_lexer_alt(&LexerAltContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_lexer_elements(&LexerElementsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_lexer_element(&LexerElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_lexer_block(&LexerBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_lexer_commands(&LexerCommandsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_lexer_command(&LexerCommandContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_lexer_command_name(&LexerCommandNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_lexer_command_expr(&LexerCommandExprContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_alt_list(&AltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_alternative(&AlternativeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_element(&ElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_predicate_options(&PredicateOptionsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_predicate_option(&PredicateOptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_labeled_element(&LabeledElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_ebnf(&EbnfContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_block_suffix(&BlockSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_ebnf_suffix(&EbnfSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_lexer_atom(&LexerAtomContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_atom(&AtomContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_wildcard(&WildcardContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_not_set(&NotSetContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_block_set(&BlockSetContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_set_element(&SetElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_ruleref(&RulerefContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_character_range(&CharacterRangeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_terminal_def(&TerminalDefContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_element_options(&ElementOptionsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_element_option(&ElementOptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_identifier(&IdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_qualified_identifier(&QualifiedIdentifierContext::__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_grammar_spec(&GrammarSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    1 => listener.exit_grammar_decl(&GrammarDeclContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_grammar_type(&GrammarTypeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_prequel_construct(&PrequelConstructContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_options_spec(&OptionsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_option(&OptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_option_value(&OptionValueContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_delegate_grammars(&DelegateGrammarsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_delegate_grammar(&DelegateGrammarContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_tokens_spec(&TokensSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_channels_spec(&ChannelsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_id_list(&IdListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_action(&ActionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_action_scope_name(&ActionScopeNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_action_block(&ActionBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_arg_action_block(&ArgActionBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_mode_spec(&ModeSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_rules(&RulesContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_rule_spec(&RuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_parser_rule_spec(&ParserRuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_exception_group(&ExceptionGroupContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_exception_handler(&ExceptionHandlerContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_finally_clause(&FinallyClauseContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_rule_prequel(&RulePrequelContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_rule_returns(&RuleReturnsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_throws_spec(&ThrowsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_locals_spec(&LocalsSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_rule_action(&RuleActionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_rule_modifiers(&RuleModifiersContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_rule_modifier(&RuleModifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_rule_block(&RuleBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_rule_alt_list(&RuleAltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_labeled_alt(&LabeledAltContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_lexer_rule_spec(&LexerRuleSpecContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_lexer_rule_block(&LexerRuleBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_lexer_alt_list(&LexerAltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_lexer_alt(&LexerAltContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_lexer_elements(&LexerElementsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_lexer_element(&LexerElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_lexer_block(&LexerBlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_lexer_commands(&LexerCommandsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_lexer_command(&LexerCommandContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_lexer_command_name(&LexerCommandNameContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_lexer_command_expr(&LexerCommandExprContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_alt_list(&AltListContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_alternative(&AlternativeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_element(&ElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_predicate_options(&PredicateOptionsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_predicate_option(&PredicateOptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_labeled_element(&LabeledElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_ebnf(&EbnfContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_block_suffix(&BlockSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_ebnf_suffix(&EbnfSuffixContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_lexer_atom(&LexerAtomContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_atom(&AtomContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_wildcard(&WildcardContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_not_set(&NotSetContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_block_set(&BlockSetContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_set_element(&SetElementContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_block(&BlockContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_ruleref(&RulerefContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_character_range(&CharacterRangeContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_terminal_def(&TerminalDefContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_element_options(&ElementOptionsContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_element_option(&ElementOptionContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_identifier(&IdentifierContext::__from_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_qualified_identifier(&QualifiedIdentifierContext::__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 = ANTLRv4TreeWalker;

#[allow(dead_code, unused_variables)]
pub trait ANTLRv4ValidatedListener<E = std::convert::Infallible> {
    fn walk(&mut self, tree: ValidatedRuleNode<'_>) -> Result<(), E>
    where
        Self: Sized,
    {
        ANTLRv4ValidatedTreeWalker::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_grammar_spec(&mut self, _ctx: &GrammarSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_grammar_spec(&mut self, _ctx: &GrammarSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_grammar_decl(&mut self, _ctx: &GrammarDeclContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_grammar_decl(&mut self, _ctx: &GrammarDeclContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_grammar_type(&mut self, _ctx: &GrammarTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_grammar_type(&mut self, _ctx: &GrammarTypeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_prequel_construct(&mut self, _ctx: &PrequelConstructContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_prequel_construct(&mut self, _ctx: &PrequelConstructContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_options_spec(&mut self, _ctx: &OptionsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_options_spec(&mut self, _ctx: &OptionsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_option(&mut self, _ctx: &OptionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_option(&mut self, _ctx: &OptionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_option_value(&mut self, _ctx: &OptionValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_option_value(&mut self, _ctx: &OptionValueContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_delegate_grammars(&mut self, _ctx: &DelegateGrammarsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_delegate_grammars(&mut self, _ctx: &DelegateGrammarsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_delegate_grammar(&mut self, _ctx: &DelegateGrammarContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_delegate_grammar(&mut self, _ctx: &DelegateGrammarContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_tokens_spec(&mut self, _ctx: &TokensSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_tokens_spec(&mut self, _ctx: &TokensSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_channels_spec(&mut self, _ctx: &ChannelsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_channels_spec(&mut self, _ctx: &ChannelsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_id_list(&mut self, _ctx: &IdListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_id_list(&mut self, _ctx: &IdListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_action(&mut self, _ctx: &ActionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_action(&mut self, _ctx: &ActionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_action_scope_name(&mut self, _ctx: &ActionScopeNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_action_scope_name(&mut self, _ctx: &ActionScopeNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_action_block(&mut self, _ctx: &ActionBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_action_block(&mut self, _ctx: &ActionBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_arg_action_block(&mut self, _ctx: &ArgActionBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_arg_action_block(&mut self, _ctx: &ArgActionBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_mode_spec(&mut self, _ctx: &ModeSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_mode_spec(&mut self, _ctx: &ModeSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rules(&mut self, _ctx: &RulesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rules(&mut self, _ctx: &RulesContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_spec(&mut self, _ctx: &RuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_spec(&mut self, _ctx: &RuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_parser_rule_spec(&mut self, _ctx: &ParserRuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_parser_rule_spec(&mut self, _ctx: &ParserRuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_exception_group(&mut self, _ctx: &ExceptionGroupContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_exception_group(&mut self, _ctx: &ExceptionGroupContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_exception_handler(&mut self, _ctx: &ExceptionHandlerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_exception_handler(&mut self, _ctx: &ExceptionHandlerContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_finally_clause(&mut self, _ctx: &FinallyClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_finally_clause(&mut self, _ctx: &FinallyClauseContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_prequel(&mut self, _ctx: &RulePrequelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_prequel(&mut self, _ctx: &RulePrequelContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_returns(&mut self, _ctx: &RuleReturnsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_returns(&mut self, _ctx: &RuleReturnsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_throws_spec(&mut self, _ctx: &ThrowsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_throws_spec(&mut self, _ctx: &ThrowsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_locals_spec(&mut self, _ctx: &LocalsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_locals_spec(&mut self, _ctx: &LocalsSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_action(&mut self, _ctx: &RuleActionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_action(&mut self, _ctx: &RuleActionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_modifiers(&mut self, _ctx: &RuleModifiersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_modifiers(&mut self, _ctx: &RuleModifiersContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_modifier(&mut self, _ctx: &RuleModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_modifier(&mut self, _ctx: &RuleModifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_block(&mut self, _ctx: &RuleBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_block(&mut self, _ctx: &RuleBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_rule_alt_list(&mut self, _ctx: &RuleAltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_rule_alt_list(&mut self, _ctx: &RuleAltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_labeled_alt(&mut self, _ctx: &LabeledAltContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_labeled_alt(&mut self, _ctx: &LabeledAltContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_rule_spec(&mut self, _ctx: &LexerRuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_rule_spec(&mut self, _ctx: &LexerRuleSpecContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_rule_block(&mut self, _ctx: &LexerRuleBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_rule_block(&mut self, _ctx: &LexerRuleBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_alt_list(&mut self, _ctx: &LexerAltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_alt_list(&mut self, _ctx: &LexerAltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_alt(&mut self, _ctx: &LexerAltContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_alt(&mut self, _ctx: &LexerAltContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_elements(&mut self, _ctx: &LexerElementsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_elements(&mut self, _ctx: &LexerElementsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_element(&mut self, _ctx: &LexerElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_element(&mut self, _ctx: &LexerElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_block(&mut self, _ctx: &LexerBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_block(&mut self, _ctx: &LexerBlockContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_commands(&mut self, _ctx: &LexerCommandsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_commands(&mut self, _ctx: &LexerCommandsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command(&mut self, _ctx: &LexerCommandContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command(&mut self, _ctx: &LexerCommandContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command_name(&mut self, _ctx: &LexerCommandNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command_name(&mut self, _ctx: &LexerCommandNameContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_command_expr(&mut self, _ctx: &LexerCommandExprContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_command_expr(&mut self, _ctx: &LexerCommandExprContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_alt_list(&mut self, _ctx: &AltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_alt_list(&mut self, _ctx: &AltListContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_alternative(&mut self, _ctx: &AlternativeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_alternative(&mut self, _ctx: &AlternativeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element(&mut self, _ctx: &ElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element(&mut self, _ctx: &ElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_predicate_options(&mut self, _ctx: &PredicateOptionsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_predicate_options(&mut self, _ctx: &PredicateOptionsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_predicate_option(&mut self, _ctx: &PredicateOptionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_predicate_option(&mut self, _ctx: &PredicateOptionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_labeled_element(&mut self, _ctx: &LabeledElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_labeled_element(&mut self, _ctx: &LabeledElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ebnf(&mut self, _ctx: &EbnfContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ebnf(&mut self, _ctx: &EbnfContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_block_suffix(&mut self, _ctx: &BlockSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_block_suffix(&mut self, _ctx: &BlockSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_ebnf_suffix(&mut self, _ctx: &EbnfSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ebnf_suffix(&mut self, _ctx: &EbnfSuffixContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_lexer_atom(&mut self, _ctx: &LexerAtomContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_lexer_atom(&mut self, _ctx: &LexerAtomContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_atom(&mut self, _ctx: &AtomContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_atom(&mut self, _ctx: &AtomContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_wildcard(&mut self, _ctx: &WildcardContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_wildcard(&mut self, _ctx: &WildcardContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_not_set(&mut self, _ctx: &NotSetContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_not_set(&mut self, _ctx: &NotSetContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_block_set(&mut self, _ctx: &BlockSetContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_block_set(&mut self, _ctx: &BlockSetContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_set_element(&mut self, _ctx: &SetElementContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_set_element(&mut self, _ctx: &SetElementContext<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_ruleref(&mut self, _ctx: &RulerefContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_ruleref(&mut self, _ctx: &RulerefContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_character_range(&mut self, _ctx: &CharacterRangeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_character_range(&mut self, _ctx: &CharacterRangeContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_terminal_def(&mut self, _ctx: &TerminalDefContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_terminal_def(&mut self, _ctx: &TerminalDefContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element_options(&mut self, _ctx: &ElementOptionsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element_options(&mut self, _ctx: &ElementOptionsContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn enter_element_option(&mut self, _ctx: &ElementOptionContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_element_option(&mut self, _ctx: &ElementOptionContext<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_qualified_identifier(&mut self, _ctx: &QualifiedIdentifierContext<ValidatedTreeContext>) -> Result<(), E> { Ok(()) }
    fn exit_qualified_identifier(&mut self, _ctx: &QualifiedIdentifierContext<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 ANTLRv4ValidatedTreeWalker;

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

    pub fn walk_with_invocation_states<E, T: ANTLRv4ValidatedListener<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: ANTLRv4ValidatedListener<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_grammar_spec(&GrammarSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        1 => listener.enter_grammar_decl(&GrammarDeclContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        2 => listener.enter_grammar_type(&GrammarTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        3 => listener.enter_prequel_construct(&PrequelConstructContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        4 => listener.enter_options_spec(&OptionsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        5 => listener.enter_option(&OptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        6 => listener.enter_option_value(&OptionValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        7 => listener.enter_delegate_grammars(&DelegateGrammarsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        8 => listener.enter_delegate_grammar(&DelegateGrammarContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        9 => listener.enter_tokens_spec(&TokensSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        10 => listener.enter_channels_spec(&ChannelsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        11 => listener.enter_id_list(&IdListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        12 => listener.enter_action(&ActionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        13 => listener.enter_action_scope_name(&ActionScopeNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        14 => listener.enter_action_block(&ActionBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        15 => listener.enter_arg_action_block(&ArgActionBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        16 => listener.enter_mode_spec(&ModeSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        17 => listener.enter_rules(&RulesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        18 => listener.enter_rule_spec(&RuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        19 => listener.enter_parser_rule_spec(&ParserRuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        20 => listener.enter_exception_group(&ExceptionGroupContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        21 => listener.enter_exception_handler(&ExceptionHandlerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        22 => listener.enter_finally_clause(&FinallyClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        23 => listener.enter_rule_prequel(&RulePrequelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        24 => listener.enter_rule_returns(&RuleReturnsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        25 => listener.enter_throws_spec(&ThrowsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        26 => listener.enter_locals_spec(&LocalsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        27 => listener.enter_rule_action(&RuleActionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        28 => listener.enter_rule_modifiers(&RuleModifiersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        29 => listener.enter_rule_modifier(&RuleModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        30 => listener.enter_rule_block(&RuleBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        31 => listener.enter_rule_alt_list(&RuleAltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        32 => listener.enter_labeled_alt(&LabeledAltContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        33 => listener.enter_lexer_rule_spec(&LexerRuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        34 => listener.enter_lexer_rule_block(&LexerRuleBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        35 => listener.enter_lexer_alt_list(&LexerAltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        36 => listener.enter_lexer_alt(&LexerAltContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        37 => listener.enter_lexer_elements(&LexerElementsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        38 => listener.enter_lexer_element(&LexerElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        39 => listener.enter_lexer_block(&LexerBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        40 => listener.enter_lexer_commands(&LexerCommandsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        41 => listener.enter_lexer_command(&LexerCommandContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        42 => listener.enter_lexer_command_name(&LexerCommandNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        43 => listener.enter_lexer_command_expr(&LexerCommandExprContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        44 => listener.enter_alt_list(&AltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        45 => listener.enter_alternative(&AlternativeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        46 => listener.enter_element(&ElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        47 => listener.enter_predicate_options(&PredicateOptionsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        48 => listener.enter_predicate_option(&PredicateOptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        49 => listener.enter_labeled_element(&LabeledElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        50 => listener.enter_ebnf(&EbnfContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        51 => listener.enter_block_suffix(&BlockSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        52 => listener.enter_ebnf_suffix(&EbnfSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        53 => listener.enter_lexer_atom(&LexerAtomContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        54 => listener.enter_atom(&AtomContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        55 => listener.enter_wildcard(&WildcardContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        56 => listener.enter_not_set(&NotSetContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        57 => listener.enter_block_set(&BlockSetContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        58 => listener.enter_set_element(&SetElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        59 => listener.enter_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        60 => listener.enter_ruleref(&RulerefContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        61 => listener.enter_character_range(&CharacterRangeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        62 => listener.enter_terminal_def(&TerminalDefContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        63 => listener.enter_element_options(&ElementOptionsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        64 => listener.enter_element_option(&ElementOptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        65 => listener.enter_identifier(&IdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                        66 => listener.enter_qualified_identifier(&QualifiedIdentifierContext::<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_grammar_spec(&GrammarSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    1 => listener.exit_grammar_decl(&GrammarDeclContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    2 => listener.exit_grammar_type(&GrammarTypeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    3 => listener.exit_prequel_construct(&PrequelConstructContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    4 => listener.exit_options_spec(&OptionsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    5 => listener.exit_option(&OptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    6 => listener.exit_option_value(&OptionValueContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    7 => listener.exit_delegate_grammars(&DelegateGrammarsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    8 => listener.exit_delegate_grammar(&DelegateGrammarContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    9 => listener.exit_tokens_spec(&TokensSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    10 => listener.exit_channels_spec(&ChannelsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    11 => listener.exit_id_list(&IdListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    12 => listener.exit_action(&ActionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    13 => listener.exit_action_scope_name(&ActionScopeNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    14 => listener.exit_action_block(&ActionBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    15 => listener.exit_arg_action_block(&ArgActionBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    16 => listener.exit_mode_spec(&ModeSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    17 => listener.exit_rules(&RulesContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    18 => listener.exit_rule_spec(&RuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    19 => listener.exit_parser_rule_spec(&ParserRuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    20 => listener.exit_exception_group(&ExceptionGroupContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    21 => listener.exit_exception_handler(&ExceptionHandlerContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    22 => listener.exit_finally_clause(&FinallyClauseContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    23 => listener.exit_rule_prequel(&RulePrequelContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    24 => listener.exit_rule_returns(&RuleReturnsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    25 => listener.exit_throws_spec(&ThrowsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    26 => listener.exit_locals_spec(&LocalsSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    27 => listener.exit_rule_action(&RuleActionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    28 => listener.exit_rule_modifiers(&RuleModifiersContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    29 => listener.exit_rule_modifier(&RuleModifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    30 => listener.exit_rule_block(&RuleBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    31 => listener.exit_rule_alt_list(&RuleAltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    32 => listener.exit_labeled_alt(&LabeledAltContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    33 => listener.exit_lexer_rule_spec(&LexerRuleSpecContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    34 => listener.exit_lexer_rule_block(&LexerRuleBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    35 => listener.exit_lexer_alt_list(&LexerAltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    36 => listener.exit_lexer_alt(&LexerAltContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    37 => listener.exit_lexer_elements(&LexerElementsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    38 => listener.exit_lexer_element(&LexerElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    39 => listener.exit_lexer_block(&LexerBlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    40 => listener.exit_lexer_commands(&LexerCommandsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    41 => listener.exit_lexer_command(&LexerCommandContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    42 => listener.exit_lexer_command_name(&LexerCommandNameContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    43 => listener.exit_lexer_command_expr(&LexerCommandExprContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    44 => listener.exit_alt_list(&AltListContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    45 => listener.exit_alternative(&AlternativeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    46 => listener.exit_element(&ElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    47 => listener.exit_predicate_options(&PredicateOptionsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    48 => listener.exit_predicate_option(&PredicateOptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    49 => listener.exit_labeled_element(&LabeledElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    50 => listener.exit_ebnf(&EbnfContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    51 => listener.exit_block_suffix(&BlockSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    52 => listener.exit_ebnf_suffix(&EbnfSuffixContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    53 => listener.exit_lexer_atom(&LexerAtomContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    54 => listener.exit_atom(&AtomContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    55 => listener.exit_wildcard(&WildcardContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    56 => listener.exit_not_set(&NotSetContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    57 => listener.exit_block_set(&BlockSetContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    58 => listener.exit_set_element(&SetElementContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    59 => listener.exit_block(&BlockContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    60 => listener.exit_ruleref(&RulerefContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    61 => listener.exit_character_range(&CharacterRangeContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    62 => listener.exit_terminal_def(&TerminalDefContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    63 => listener.exit_element_options(&ElementOptionsContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    64 => listener.exit_element_option(&ElementOptionContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    65 => listener.exit_identifier(&IdentifierContext::<ValidatedTreeContext>::__from_validated_listener_node(context, invocation_states.as_deref()))?,
                    66 => listener.exit_qualified_identifier(&QualifiedIdentifierContext::<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 = ANTLRv4ValidatedTreeWalker;



static PARSER_ATN_DATA: &[u32] = &[1346458702, 2, 16909060, 29, 78, 650, 823, 3, 6, 85, 67, 29, 4550, 4579, 4115, 8694, 15, 8709, 12, 8733, 85, 8818, 67, 8885, 67, 8952, 6, 8721, 12, 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, 1, 4294967295, 4294967295, 2, 4, 8, 7, 1, 4294967295, 4294967295, 7, 4, 24, 8, 4, 4294967295, 4294967295, 2, 5, 8, 12, 1, 4294967295, 4294967295, 7, 5, 24, 13, 1, 4294967295, 4294967295, 2, 6, 8, 14, 1, 4294967295, 4294967295, 7, 6, 24, 15, 1, 4294967295, 4294967295, 2, 7, 8, 16, 1, 4294967295, 4294967295, 7, 7, 24, 17, 1, 4294967295, 4294967295, 2, 8, 8, 18, 1, 4294967295, 4294967295, 7, 8, 24, 19, 2, 4294967295, 4294967295, 2, 9, 8, 21, 1, 4294967295, 4294967295, 7, 9, 24, 22, 1, 4294967295, 4294967295, 2, 10, 8, 23, 1, 4294967295, 4294967295, 7, 10, 24, 24, 1, 4294967295, 4294967295, 2, 11, 8, 25, 1, 4294967295, 4294967295, 7, 11, 24, 26, 2, 4294967295, 4294967295, 2, 12, 8, 28, 1, 4294967295, 4294967295, 7, 12, 24, 29, 1, 4294967295, 4294967295, 2, 13, 8, 30, 1, 4294967295, 4294967295, 7, 13, 24, 31, 1, 4294967295, 4294967295, 2, 14, 8, 32, 1, 4294967295, 4294967295, 7, 14, 24, 33, 8, 4294967295, 4294967295, 2, 15, 8, 41, 1, 4294967295, 4294967295, 7, 15, 24, 42, 5, 4294967295, 4294967295, 2, 16, 8, 47, 1, 4294967295, 4294967295, 7, 16, 24, 48, 1, 4294967295, 4294967295, 2, 17, 8, 49, 1, 4294967295, 4294967295, 7, 17, 24, 50, 1, 4294967295, 4294967295, 2, 18, 8, 51, 1, 4294967295, 4294967295, 7, 18, 24, 52, 1, 4294967295, 4294967295, 2, 19, 8, 53, 1, 4294967295, 4294967295, 7, 19, 24, 54, 1, 4294967295, 4294967295, 2, 20, 8, 55, 1, 4294967295, 4294967295, 7, 20, 24, 56, 1, 4294967295, 4294967295, 2, 21, 8, 57, 1, 4294967295, 4294967295, 7, 21, 24, 58, 1, 4294967295, 4294967295, 2, 22, 8, 59, 1, 4294967295, 4294967295, 7, 22, 24, 60, 1, 4294967295, 4294967295, 2, 23, 8, 61, 1, 4294967295, 4294967295, 7, 23, 24, 62, 1, 4294967295, 4294967295, 2, 24, 8, 63, 1, 4294967295, 4294967295, 7, 24, 24, 64, 1, 4294967295, 4294967295, 2, 25, 8, 65, 1, 4294967295, 4294967295, 7, 25, 24, 66, 1, 4294967295, 4294967295, 2, 26, 8, 67, 1, 4294967295, 4294967295, 7, 26, 24, 68, 1, 4294967295, 4294967295, 2, 27, 8, 69, 1, 4294967295, 4294967295, 7, 27, 24, 70, 2, 4294967295, 4294967295, 2, 28, 8, 72, 1, 4294967295, 4294967295, 7, 28, 24, 73, 1, 4294967295, 4294967295, 2, 29, 8, 74, 1, 4294967295, 4294967295, 7, 29, 24, 75, 1, 4294967295, 4294967295, 2, 30, 8, 76, 1, 4294967295, 4294967295, 7, 30, 24, 77, 1, 4294967295, 4294967295, 2, 31, 8, 78, 1, 4294967295, 4294967295, 7, 31, 24, 79, 1, 4294967295, 4294967295, 2, 32, 8, 80, 1, 4294967295, 4294967295, 7, 32, 24, 81, 2, 4294967295, 4294967295, 2, 33, 8, 83, 1, 4294967295, 4294967295, 7, 33, 24, 84, 2, 4294967295, 4294967295, 2, 34, 8, 86, 1, 4294967295, 4294967295, 7, 34, 24, 87, 1, 4294967295, 4294967295, 2, 35, 8, 88, 1, 4294967295, 4294967295, 7, 35, 24, 89, 2, 4294967295, 4294967295, 2, 36, 8, 91, 1, 4294967295, 4294967295, 7, 36, 24, 92, 2, 4294967295, 4294967295, 2, 37, 8, 94, 1, 4294967295, 4294967295, 7, 37, 24, 95, 1, 4294967295, 4294967295, 2, 38, 8, 96, 1, 4294967295, 4294967295, 7, 38, 24, 97, 1, 4294967295, 4294967295, 2, 39, 8, 98, 1, 4294967295, 4294967295, 7, 39, 24, 99, 1, 4294967295, 4294967295, 2, 40, 8, 100, 1, 4294967295, 4294967295, 7, 40, 24, 101, 1, 4294967295, 4294967295, 2, 41, 8, 102, 1, 4294967295, 4294967295, 7, 41, 24, 103, 2, 4294967295, 4294967295, 2, 42, 8, 105, 1, 4294967295, 4294967295, 7, 42, 24, 106, 2, 4294967295, 4294967295, 2, 43, 8, 108, 1, 4294967295, 4294967295, 7, 43, 24, 109, 1, 4294967295, 4294967295, 2, 44, 8, 110, 1, 4294967295, 4294967295, 7, 44, 24, 111, 1, 4294967295, 4294967295, 2, 45, 8, 112, 1, 4294967295, 4294967295, 7, 45, 24, 113, 3, 4294967295, 4294967295, 2, 46, 8, 116, 1, 4294967295, 4294967295, 7, 46, 24, 117, 1, 4294967295, 4294967295, 2, 47, 8, 118, 1, 4294967295, 4294967295, 7, 47, 24, 119, 1, 4294967295, 4294967295, 2, 48, 8, 120, 1, 4294967295, 4294967295, 7, 48, 24, 121, 2, 4294967295, 4294967295, 2, 49, 8, 123, 1, 4294967295, 4294967295, 7, 49, 24, 124, 1, 4294967295, 4294967295, 2, 50, 8, 125, 1, 4294967295, 4294967295, 7, 50, 24, 126, 1, 4294967295, 4294967295, 2, 51, 8, 127, 1, 4294967295, 4294967295, 7, 51, 24, 128, 1, 4294967295, 4294967295, 2, 52, 8, 129, 1, 4294967295, 4294967295, 7, 52, 24, 130, 5, 4294967295, 4294967295, 2, 53, 8, 135, 1, 4294967295, 4294967295, 7, 53, 24, 136, 1, 4294967295, 4294967295, 2, 54, 8, 137, 1, 4294967295, 4294967295, 7, 54, 24, 138, 2, 4294967295, 4294967295, 2, 55, 8, 140, 1, 4294967295, 4294967295, 7, 55, 24, 141, 2, 4294967295, 4294967295, 2, 56, 8, 143, 1, 4294967295, 4294967295, 7, 56, 24, 144, 2, 4294967295, 4294967295, 2, 57, 8, 146, 1, 4294967295, 4294967295, 7, 57, 24, 147, 1, 4294967295, 4294967295, 2, 58, 8, 148, 1, 4294967295, 4294967295, 7, 58, 24, 149, 3, 4294967295, 4294967295, 2, 59, 8, 152, 1, 4294967295, 4294967295, 7, 59, 24, 153, 2, 4294967295, 4294967295, 2, 60, 8, 155, 1, 4294967295, 4294967295, 7, 60, 24, 156, 1, 4294967295, 4294967295, 2, 61, 8, 157, 1, 4294967295, 4294967295, 7, 61, 24, 158, 2, 4294967295, 4294967295, 2, 62, 8, 160, 1, 4294967295, 4294967295, 7, 62, 24, 161, 2, 4294967295, 4294967295, 2, 63, 8, 163, 1, 4294967295, 4294967295, 7, 63, 24, 164, 7, 4294967295, 4294967295, 2, 64, 8, 171, 1, 4294967295, 4294967295, 7, 64, 24, 172, 3, 4294967295, 4294967295, 2, 65, 8, 175, 1, 4294967295, 4294967295, 7, 65, 24, 176, 21, 4294967295, 4294967295, 2, 66, 8, 197, 1, 4294967295, 4294967295, 7, 66, 24, 198, 4, 4294967295, 4294967295, 1, 0, 8, 202, 1, 4294967295, 4294967295, 1, 0, 8, 203, 1, 4294967295, 4294967295, 5, 0, 8, 204, 1, 137, 4294967295, 8, 0, 8, 205, 1, 4294967295, 4294967295, 10, 0, 8, 206, 2, 4294967295, 4294967295, 12, 0, 8, 208, 1, 4294967295, 140, 9, 0, 8, 209, 1, 4294967295, 4294967295, 1, 0, 8, 210, 1, 4294967295, 4294967295, 1, 0, 8, 211, 1, 4294967295, 4294967295, 5, 0, 8, 212, 1, 144, 4294967295, 8, 0, 8, 213, 1, 4294967295, 4294967295, 10, 0, 8, 214, 2, 4294967295, 4294967295, 12, 0, 8, 216, 1, 4294967295, 147, 9, 0, 8, 217, 1, 4294967295, 4294967295, 1, 0, 32, 218, 1, 4294967295, 4294967295, 1, 0, 8, 219, 1, 4294967295, 4294967295, 1, 1, 8, 220, 1, 4294967295, 4294967295, 1, 1, 8, 221, 1, 4294967295, 4294967295, 1, 1, 32, 222, 1, 4294967295, 4294967295, 1, 1, 8, 223, 1, 4294967295, 4294967295, 1, 2, 32, 224, 1, 4294967295, 4294967295, 1, 2, 32, 225, 1, 4294967295, 4294967295, 1, 2, 32, 226, 1, 4294967295, 4294967295, 1, 2, 32, 227, 1, 4294967295, 4294967295, 1, 2, 32, 228, 1, 4294967295, 4294967295, 3, 2, 8, 229, 3, 160, 4294967295, 8, 2, 8, 232, 1, 4294967295, 4294967295, 1, 3, 8, 233, 1, 4294967295, 4294967295, 1, 3, 8, 234, 1, 4294967295, 4294967295, 1, 3, 8, 235, 1, 4294967295, 4294967295, 1, 3, 8, 236, 1, 4294967295, 4294967295, 1, 3, 8, 237, 1, 4294967295, 4294967295, 3, 3, 8, 238, 5, 167, 4294967295, 8, 3, 8, 243, 1, 4294967295, 4294967295, 1, 4, 32, 244, 1, 4294967295, 4294967295, 1, 4, 8, 245, 1, 4294967295, 4294967295, 1, 4, 32, 246, 1, 4294967295, 4294967295, 1, 4, 8, 247, 1, 4294967295, 4294967295, 5, 4, 8, 248, 1, 173, 4294967295, 8, 4, 8, 249, 1, 4294967295, 4294967295, 10, 4, 8, 250, 2, 4294967295, 4294967295, 12, 4, 8, 252, 1, 4294967295, 176, 9, 4, 8, 253, 1, 4294967295, 4294967295, 1, 4, 32, 254, 1, 4294967295, 4294967295, 1, 4, 8, 255, 1, 4294967295, 4294967295, 1, 5, 8, 256, 1, 4294967295, 4294967295, 1, 5, 32, 257, 1, 4294967295, 4294967295, 1, 5, 8, 258, 1, 4294967295, 4294967295, 1, 5, 8, 259, 1, 4294967295, 4294967295, 1, 6, 8, 260, 1, 4294967295, 4294967295, 1, 6, 32, 261, 1, 4294967295, 4294967295, 1, 6, 8, 262, 1, 4294967295, 4294967295, 5, 6, 8, 263, 1, 187, 4294967295, 8, 6, 8, 264, 1, 4294967295, 4294967295, 10, 6, 8, 265, 2, 4294967295, 4294967295, 12, 6, 8, 267, 1, 4294967295, 190, 9, 6, 8, 268, 1, 4294967295, 4294967295, 1, 6, 32, 269, 1, 4294967295, 4294967295, 1, 6, 8, 270, 1, 4294967295, 4294967295, 1, 6, 32, 271, 1, 4294967295, 4294967295, 3, 6, 8, 272, 4, 195, 4294967295, 8, 6, 8, 276, 1, 4294967295, 4294967295, 1, 7, 32, 277, 1, 4294967295, 4294967295, 1, 7, 8, 278, 1, 4294967295, 4294967295, 1, 7, 32, 279, 1, 4294967295, 4294967295, 1, 7, 8, 280, 1, 4294967295, 4294967295, 5, 7, 8, 281, 1, 201, 4294967295, 8, 7, 8, 282, 1, 4294967295, 4294967295, 10, 7, 8, 283, 2, 4294967295, 4294967295, 12, 7, 8, 285, 1, 4294967295, 204, 9, 7, 8, 286, 1, 4294967295, 4294967295, 1, 7, 32, 287, 1, 4294967295, 4294967295, 1, 7, 8, 288, 1, 4294967295, 4294967295, 1, 8, 8, 289, 1, 4294967295, 4294967295, 1, 8, 32, 290, 1, 4294967295, 4294967295, 1, 8, 8, 291, 1, 4294967295, 4294967295, 1, 8, 8, 292, 1, 4294967295, 4294967295, 1, 8, 8, 293, 1, 4294967295, 4294967295, 3, 8, 8, 294, 2, 213, 4294967295, 8, 8, 8, 296, 1, 4294967295, 4294967295, 1, 9, 32, 297, 1, 4294967295, 4294967295, 1, 9, 8, 298, 1, 4294967295, 4294967295, 3, 9, 8, 299, 2, 217, 4294967295, 8, 9, 8, 301, 1, 4294967295, 4294967295, 1, 9, 32, 302, 1, 4294967295, 4294967295, 1, 9, 8, 303, 1, 4294967295, 4294967295, 1, 10, 32, 304, 1, 4294967295, 4294967295, 1, 10, 8, 305, 1, 4294967295, 4294967295, 3, 10, 8, 306, 2, 223, 4294967295, 8, 10, 8, 308, 1, 4294967295, 4294967295, 1, 10, 32, 309, 1, 4294967295, 4294967295, 1, 10, 8, 310, 1, 4294967295, 4294967295, 1, 11, 8, 311, 1, 4294967295, 4294967295, 1, 11, 32, 312, 1, 4294967295, 4294967295, 1, 11, 8, 313, 1, 4294967295, 4294967295, 5, 11, 8, 314, 1, 230, 4294967295, 8, 11, 8, 315, 1, 4294967295, 4294967295, 10, 11, 8, 316, 2, 4294967295, 4294967295, 12, 11, 8, 318, 1, 4294967295, 233, 9, 11, 8, 319, 1, 4294967295, 4294967295, 1, 11, 32, 320, 1, 4294967295, 4294967295, 3, 11, 8, 321, 2, 236, 4294967295, 8, 11, 8, 323, 1, 4294967295, 4294967295, 1, 12, 32, 324, 1, 4294967295, 4294967295, 1, 12, 8, 325, 1, 4294967295, 4294967295, 1, 12, 32, 326, 1, 4294967295, 4294967295, 1, 12, 8, 327, 1, 4294967295, 4294967295, 3, 12, 8, 328, 2, 242, 4294967295, 8, 12, 8, 330, 1, 4294967295, 4294967295, 1, 12, 8, 331, 1, 4294967295, 4294967295, 1, 12, 8, 332, 1, 4294967295, 4294967295, 1, 12, 8, 333, 1, 4294967295, 4294967295, 1, 13, 8, 334, 1, 4294967295, 4294967295, 1, 13, 32, 335, 1, 4294967295, 4294967295, 1, 13, 32, 336, 1, 4294967295, 4294967295, 3, 13, 8, 337, 3, 250, 4294967295, 8, 13, 8, 340, 1, 4294967295, 4294967295, 1, 14, 32, 341, 1, 4294967295, 4294967295, 1, 14, 8, 342, 1, 4294967295, 4294967295, 1, 15, 32, 343, 1, 4294967295, 4294967295, 1, 15, 32, 344, 1, 4294967295, 4294967295, 5, 15, 8, 345, 1, 256, 4294967295, 8, 15, 8, 346, 1, 4294967295, 4294967295, 10, 15, 9, 347, 2, 4294967295, 4294967295, 12, 15, 8, 349, 1, 4294967295, 259, 9, 15, 8, 350, 1, 4294967295, 4294967295, 1, 15, 32, 351, 1, 4294967295, 4294967295, 1, 15, 8, 352, 1, 4294967295, 4294967295, 1, 16, 32, 353, 1, 4294967295, 4294967295, 1, 16, 8, 354, 1, 4294967295, 4294967295, 1, 16, 32, 355, 1, 4294967295, 4294967295, 1, 16, 8, 356, 1, 4294967295, 4294967295, 5, 16, 8, 357, 1, 267, 4294967295, 8, 16, 8, 358, 1, 4294967295, 4294967295, 10, 16, 8, 359, 2, 4294967295, 4294967295, 12, 16, 8, 361, 1, 4294967295, 270, 9, 16, 8, 362, 1, 4294967295, 4294967295, 1, 17, 8, 363, 1, 4294967295, 4294967295, 5, 17, 8, 364, 1, 273, 4294967295, 8, 17, 8, 365, 1, 4294967295, 4294967295, 10, 17, 8, 366, 2, 4294967295, 4294967295, 12, 17, 8, 368, 1, 4294967295, 276, 9, 17, 8, 369, 1, 4294967295, 4294967295, 1, 18, 8, 370, 1, 4294967295, 4294967295, 1, 18, 8, 371, 1, 4294967295, 4294967295, 3, 18, 8, 372, 2, 280, 4294967295, 8, 18, 8, 374, 1, 4294967295, 4294967295, 1, 19, 8, 375, 1, 4294967295, 4294967295, 3, 19, 8, 376, 2, 283, 4294967295, 8, 19, 8, 378, 1, 4294967295, 4294967295, 1, 19, 32, 379, 1, 4294967295, 4294967295, 1, 19, 8, 380, 1, 4294967295, 4294967295, 3, 19, 8, 381, 2, 287, 4294967295, 8, 19, 8, 383, 1, 4294967295, 4294967295, 1, 19, 8, 384, 1, 4294967295, 4294967295, 3, 19, 8, 385, 2, 290, 4294967295, 8, 19, 8, 387, 1, 4294967295, 4294967295, 1, 19, 8, 388, 1, 4294967295, 4294967295, 3, 19, 8, 389, 2, 293, 4294967295, 8, 19, 8, 391, 1, 4294967295, 4294967295, 1, 19, 8, 392, 1, 4294967295, 4294967295, 3, 19, 8, 393, 2, 296, 4294967295, 8, 19, 8, 395, 1, 4294967295, 4294967295, 1, 19, 8, 396, 1, 4294967295, 4294967295, 5, 19, 8, 397, 1, 299, 4294967295, 8, 19, 8, 398, 1, 4294967295, 4294967295, 10, 19, 8, 399, 2, 4294967295, 4294967295, 12, 19, 8, 401, 1, 4294967295, 302, 9, 19, 8, 402, 1, 4294967295, 4294967295, 1, 19, 32, 403, 1, 4294967295, 4294967295, 1, 19, 8, 404, 1, 4294967295, 4294967295, 1, 19, 32, 405, 1, 4294967295, 4294967295, 1, 19, 8, 406, 1, 4294967295, 4294967295, 1, 19, 8, 407, 1, 4294967295, 4294967295, 1, 20, 8, 408, 1, 4294967295, 4294967295, 5, 20, 8, 409, 1, 310, 4294967295, 8, 20, 8, 410, 1, 4294967295, 4294967295, 10, 20, 8, 411, 2, 4294967295, 4294967295, 12, 20, 8, 413, 1, 4294967295, 313, 9, 20, 8, 414, 1, 4294967295, 4294967295, 1, 20, 8, 415, 1, 4294967295, 4294967295, 3, 20, 8, 416, 2, 316, 4294967295, 8, 20, 8, 418, 1, 4294967295, 4294967295, 1, 21, 32, 419, 1, 4294967295, 4294967295, 1, 21, 8, 420, 1, 4294967295, 4294967295, 1, 21, 8, 421, 1, 4294967295, 4294967295, 1, 21, 8, 422, 1, 4294967295, 4294967295, 1, 22, 32, 423, 1, 4294967295, 4294967295, 1, 22, 8, 424, 1, 4294967295, 4294967295, 1, 22, 8, 425, 1, 4294967295, 4294967295, 1, 23, 8, 426, 1, 4294967295, 4294967295, 1, 23, 8, 427, 1, 4294967295, 4294967295, 3, 23, 8, 428, 2, 327, 4294967295, 8, 23, 8, 430, 1, 4294967295, 4294967295, 1, 24, 32, 431, 1, 4294967295, 4294967295, 1, 24, 8, 432, 1, 4294967295, 4294967295, 1, 24, 8, 433, 1, 4294967295, 4294967295, 1, 25, 32, 434, 1, 4294967295, 4294967295, 1, 25, 8, 435, 1, 4294967295, 4294967295, 1, 25, 32, 436, 1, 4294967295, 4294967295, 1, 25, 8, 437, 1, 4294967295, 4294967295, 5, 25, 8, 438, 1, 336, 4294967295, 8, 25, 8, 439, 1, 4294967295, 4294967295, 10, 25, 8, 440, 2, 4294967295, 4294967295, 12, 25, 8, 442, 1, 4294967295, 339, 9, 25, 8, 443, 1, 4294967295, 4294967295, 1, 26, 32, 444, 1, 4294967295, 4294967295, 1, 26, 8, 445, 1, 4294967295, 4294967295, 1, 26, 8, 446, 1, 4294967295, 4294967295, 1, 27, 32, 447, 1, 4294967295, 4294967295, 1, 27, 8, 448, 1, 4294967295, 4294967295, 1, 27, 8, 449, 1, 4294967295, 4294967295, 1, 27, 8, 450, 1, 4294967295, 4294967295, 1, 28, 8, 451, 1, 4294967295, 4294967295, 4, 28, 8, 452, 1, 349, 4294967295, 8, 28, 8, 453, 1, 4294967295, 4294967295, 11, 28, 8, 454, 2, 4294967295, 4294967295, 12, 28, 8, 456, 1, 4294967295, 350, 1, 29, 32, 457, 1, 4294967295, 4294967295, 1, 29, 8, 458, 1, 4294967295, 4294967295, 1, 30, 8, 459, 1, 4294967295, 4294967295, 1, 30, 8, 460, 1, 4294967295, 4294967295, 1, 31, 8, 461, 1, 4294967295, 4294967295, 1, 31, 32, 462, 1, 4294967295, 4294967295, 1, 31, 8, 463, 1, 4294967295, 4294967295, 5, 31, 8, 464, 1, 360, 4294967295, 8, 31, 8, 465, 1, 4294967295, 4294967295, 10, 31, 8, 466, 2, 4294967295, 4294967295, 12, 31, 8, 468, 1, 4294967295, 363, 9, 31, 8, 469, 1, 4294967295, 4294967295, 1, 32, 8, 470, 1, 4294967295, 4294967295, 1, 32, 32, 471, 1, 4294967295, 4294967295, 1, 32, 8, 472, 1, 4294967295, 4294967295, 3, 32, 8, 473, 2, 368, 4294967295, 8, 32, 8, 475, 1, 4294967295, 4294967295, 1, 33, 32, 476, 1, 4294967295, 4294967295, 3, 33, 8, 477, 2, 371, 4294967295, 8, 33, 8, 479, 1, 4294967295, 4294967295, 1, 33, 32, 480, 1, 4294967295, 4294967295, 1, 33, 8, 481, 1, 4294967295, 4294967295, 3, 33, 8, 482, 2, 375, 4294967295, 8, 33, 8, 484, 1, 4294967295, 4294967295, 1, 33, 32, 485, 1, 4294967295, 4294967295, 1, 33, 8, 486, 1, 4294967295, 4294967295, 1, 33, 32, 487, 1, 4294967295, 4294967295, 1, 33, 8, 488, 1, 4294967295, 4294967295, 1, 34, 8, 489, 1, 4294967295, 4294967295, 1, 34, 8, 490, 1, 4294967295, 4294967295, 1, 35, 8, 491, 1, 4294967295, 4294967295, 1, 35, 32, 492, 1, 4294967295, 4294967295, 1, 35, 8, 493, 1, 4294967295, 4294967295, 5, 35, 8, 494, 1, 386, 4294967295, 8, 35, 8, 495, 1, 4294967295, 4294967295, 10, 35, 8, 496, 2, 4294967295, 4294967295, 12, 35, 8, 498, 1, 4294967295, 389, 9, 35, 8, 499, 1, 4294967295, 4294967295, 1, 36, 8, 500, 1, 4294967295, 4294967295, 1, 36, 8, 501, 1, 4294967295, 4294967295, 3, 36, 8, 502, 2, 393, 4294967295, 8, 36, 8, 504, 1, 4294967295, 4294967295, 1, 36, 8, 505, 1, 4294967295, 4294967295, 3, 36, 8, 506, 2, 396, 4294967295, 8, 36, 8, 508, 1, 4294967295, 4294967295, 1, 37, 8, 509, 1, 4294967295, 4294967295, 4, 37, 8, 510, 1, 399, 4294967295, 8, 37, 8, 511, 1, 4294967295, 4294967295, 11, 37, 8, 512, 2, 4294967295, 4294967295, 12, 37, 8, 514, 1, 4294967295, 400, 1, 37, 8, 515, 1, 4294967295, 4294967295, 3, 37, 8, 516, 2, 404, 4294967295, 8, 37, 8, 518, 1, 4294967295, 4294967295, 1, 38, 8, 519, 1, 4294967295, 4294967295, 1, 38, 8, 520, 1, 4294967295, 4294967295, 3, 38, 8, 521, 2, 408, 4294967295, 8, 38, 8, 523, 1, 4294967295, 4294967295, 1, 38, 8, 524, 1, 4294967295, 4294967295, 1, 38, 8, 525, 1, 4294967295, 4294967295, 3, 38, 8, 526, 2, 412, 4294967295, 8, 38, 8, 528, 1, 4294967295, 4294967295, 1, 38, 8, 529, 1, 4294967295, 4294967295, 1, 38, 32, 530, 1, 4294967295, 4294967295, 3, 38, 8, 531, 2, 416, 4294967295, 8, 38, 8, 533, 1, 4294967295, 4294967295, 3, 38, 8, 534, 3, 418, 4294967295, 8, 38, 8, 537, 1, 4294967295, 4294967295, 1, 39, 32, 538, 1, 4294967295, 4294967295, 1, 39, 8, 539, 1, 4294967295, 4294967295, 1, 39, 32, 540, 1, 4294967295, 4294967295, 1, 39, 8, 541, 1, 4294967295, 4294967295, 1, 40, 32, 542, 1, 4294967295, 4294967295, 1, 40, 8, 543, 1, 4294967295, 4294967295, 1, 40, 32, 544, 1, 4294967295, 4294967295, 1, 40, 8, 545, 1, 4294967295, 4294967295, 5, 40, 8, 546, 1, 428, 4294967295, 8, 40, 8, 547, 1, 4294967295, 4294967295, 10, 40, 8, 548, 2, 4294967295, 4294967295, 12, 40, 8, 550, 1, 4294967295, 431, 9, 40, 8, 551, 1, 4294967295, 4294967295, 1, 41, 8, 552, 1, 4294967295, 4294967295, 1, 41, 32, 553, 1, 4294967295, 4294967295, 1, 41, 8, 554, 1, 4294967295, 4294967295, 1, 41, 32, 555, 1, 4294967295, 4294967295, 1, 41, 8, 556, 1, 4294967295, 4294967295, 1, 41, 8, 557, 1, 4294967295, 4294967295, 3, 41, 8, 558, 2, 439, 4294967295, 8, 41, 8, 560, 1, 4294967295, 4294967295, 1, 42, 8, 561, 1, 4294967295, 4294967295, 1, 42, 32, 562, 1, 4294967295, 4294967295, 3, 42, 8, 563, 2, 443, 4294967295, 8, 42, 8, 565, 1, 4294967295, 4294967295, 1, 43, 8, 566, 1, 4294967295, 4294967295, 1, 43, 32, 567, 1, 4294967295, 4294967295, 3, 43, 8, 568, 2, 447, 4294967295, 8, 43, 8, 570, 1, 4294967295, 4294967295, 1, 44, 8, 571, 1, 4294967295, 4294967295, 1, 44, 32, 572, 1, 4294967295, 4294967295, 1, 44, 8, 573, 1, 4294967295, 4294967295, 5, 44, 8, 574, 1, 452, 4294967295, 8, 44, 8, 575, 1, 4294967295, 4294967295, 10, 44, 8, 576, 2, 4294967295, 4294967295, 12, 44, 8, 578, 1, 4294967295, 455, 9, 44, 8, 579, 1, 4294967295, 4294967295, 1, 45, 8, 580, 1, 4294967295, 4294967295, 3, 45, 8, 581, 2, 458, 4294967295, 8, 45, 8, 583, 1, 4294967295, 4294967295, 1, 45, 8, 584, 1, 4294967295, 4294967295, 4, 45, 8, 585, 1, 461, 4294967295, 8, 45, 8, 586, 1, 4294967295, 4294967295, 11, 45, 8, 587, 2, 4294967295, 4294967295, 12, 45, 8, 589, 1, 4294967295, 462, 1, 45, 8, 590, 1, 4294967295, 4294967295, 3, 45, 8, 591, 2, 466, 4294967295, 8, 45, 8, 593, 1, 4294967295, 4294967295, 1, 46, 8, 594, 1, 4294967295, 4294967295, 1, 46, 8, 595, 1, 4294967295, 4294967295, 1, 46, 8, 596, 1, 4294967295, 4294967295, 3, 46, 8, 597, 2, 471, 4294967295, 8, 46, 8, 599, 1, 4294967295, 4294967295, 1, 46, 8, 600, 1, 4294967295, 4294967295, 1, 46, 8, 601, 1, 4294967295, 4294967295, 1, 46, 8, 602, 1, 4294967295, 4294967295, 3, 46, 8, 603, 2, 476, 4294967295, 8, 46, 8, 605, 1, 4294967295, 4294967295, 1, 46, 8, 606, 1, 4294967295, 4294967295, 1, 46, 8, 607, 1, 4294967295, 4294967295, 1, 46, 32, 608, 1, 4294967295, 4294967295, 3, 46, 8, 609, 2, 481, 4294967295, 8, 46, 8, 611, 1, 4294967295, 4294967295, 1, 46, 8, 612, 1, 4294967295, 4294967295, 3, 46, 8, 613, 2, 484, 4294967295, 8, 46, 8, 615, 1, 4294967295, 4294967295, 3, 46, 8, 616, 4, 486, 4294967295, 8, 46, 8, 620, 1, 4294967295, 4294967295, 1, 47, 32, 621, 1, 4294967295, 4294967295, 1, 47, 8, 622, 1, 4294967295, 4294967295, 1, 47, 32, 623, 1, 4294967295, 4294967295, 1, 47, 8, 624, 1, 4294967295, 4294967295, 5, 47, 8, 625, 1, 492, 4294967295, 8, 47, 8, 626, 1, 4294967295, 4294967295, 10, 47, 8, 627, 2, 4294967295, 4294967295, 12, 47, 8, 629, 1, 4294967295, 495, 9, 47, 8, 630, 1, 4294967295, 4294967295, 1, 47, 32, 631, 1, 4294967295, 4294967295, 1, 47, 8, 632, 1, 4294967295, 4294967295, 1, 48, 8, 633, 1, 4294967295, 4294967295, 1, 48, 8, 634, 1, 4294967295, 4294967295, 1, 48, 32, 635, 1, 4294967295, 4294967295, 1, 48, 8, 636, 1, 4294967295, 4294967295, 1, 48, 32, 637, 1, 4294967295, 4294967295, 1, 48, 32, 638, 1, 4294967295, 4294967295, 3, 48, 8, 639, 3, 505, 4294967295, 8, 48, 8, 642, 1, 4294967295, 4294967295, 3, 48, 8, 643, 2, 507, 4294967295, 8, 48, 8, 645, 1, 4294967295, 4294967295, 1, 49, 8, 646, 1, 4294967295, 4294967295, 1, 49, 32, 647, 1, 4294967295, 4294967295, 1, 49, 8, 648, 1, 4294967295, 4294967295, 1, 49, 8, 649, 1, 4294967295, 4294967295, 3, 49, 8, 650, 2, 513, 4294967295, 8, 49, 8, 652, 1, 4294967295, 4294967295, 1, 50, 8, 653, 1, 4294967295, 4294967295, 1, 50, 8, 654, 1, 4294967295, 4294967295, 3, 50, 8, 655, 2, 517, 4294967295, 8, 50, 8, 657, 1, 4294967295, 4294967295, 1, 51, 8, 658, 1, 4294967295, 4294967295, 1, 51, 8, 659, 1, 4294967295, 4294967295, 1, 52, 32, 660, 1, 4294967295, 4294967295, 1, 52, 32, 661, 1, 4294967295, 4294967295, 3, 52, 8, 662, 2, 523, 4294967295, 8, 52, 8, 664, 1, 4294967295, 4294967295, 1, 52, 32, 665, 1, 4294967295, 4294967295, 1, 52, 32, 666, 1, 4294967295, 4294967295, 3, 52, 8, 667, 2, 527, 4294967295, 8, 52, 8, 669, 1, 4294967295, 4294967295, 1, 52, 32, 670, 1, 4294967295, 4294967295, 1, 52, 32, 671, 1, 4294967295, 4294967295, 3, 52, 8, 672, 2, 531, 4294967295, 8, 52, 8, 674, 1, 4294967295, 4294967295, 3, 52, 8, 675, 3, 533, 4294967295, 8, 52, 8, 678, 1, 4294967295, 4294967295, 1, 53, 8, 679, 1, 4294967295, 4294967295, 1, 53, 8, 680, 1, 4294967295, 4294967295, 1, 53, 32, 681, 1, 4294967295, 4294967295, 1, 53, 8, 682, 1, 4294967295, 4294967295, 1, 53, 32, 683, 1, 4294967295, 4294967295, 1, 53, 8, 684, 1, 4294967295, 4294967295, 3, 53, 8, 685, 6, 541, 4294967295, 8, 53, 8, 691, 1, 4294967295, 4294967295, 1, 54, 8, 692, 1, 4294967295, 4294967295, 1, 54, 8, 693, 1, 4294967295, 4294967295, 1, 54, 8, 694, 1, 4294967295, 4294967295, 1, 54, 8, 695, 1, 4294967295, 4294967295, 3, 54, 8, 696, 4, 547, 4294967295, 8, 54, 8, 700, 1, 4294967295, 4294967295, 1, 55, 32, 701, 1, 4294967295, 4294967295, 1, 55, 8, 702, 1, 4294967295, 4294967295, 3, 55, 8, 703, 2, 551, 4294967295, 8, 55, 8, 705, 1, 4294967295, 4294967295, 1, 56, 32, 706, 1, 4294967295, 4294967295, 1, 56, 8, 707, 1, 4294967295, 4294967295, 1, 56, 32, 708, 1, 4294967295, 4294967295, 1, 56, 8, 709, 1, 4294967295, 4294967295, 3, 56, 8, 710, 2, 557, 4294967295, 8, 56, 8, 712, 1, 4294967295, 4294967295, 1, 57, 32, 713, 1, 4294967295, 4294967295, 1, 57, 8, 714, 1, 4294967295, 4294967295, 1, 57, 32, 715, 1, 4294967295, 4294967295, 1, 57, 8, 716, 1, 4294967295, 4294967295, 5, 57, 8, 717, 1, 563, 4294967295, 8, 57, 8, 718, 1, 4294967295, 4294967295, 10, 57, 8, 719, 2, 4294967295, 4294967295, 12, 57, 8, 721, 1, 4294967295, 566, 9, 57, 8, 722, 1, 4294967295, 4294967295, 1, 57, 32, 723, 1, 4294967295, 4294967295, 1, 57, 8, 724, 1, 4294967295, 4294967295, 1, 58, 32, 725, 1, 4294967295, 4294967295, 1, 58, 8, 726, 1, 4294967295, 4294967295, 3, 58, 8, 727, 2, 572, 4294967295, 8, 58, 8, 729, 1, 4294967295, 4294967295, 1, 58, 32, 730, 1, 4294967295, 4294967295, 1, 58, 8, 731, 1, 4294967295, 4294967295, 3, 58, 8, 732, 2, 576, 4294967295, 8, 58, 8, 734, 1, 4294967295, 4294967295, 1, 58, 8, 735, 1, 4294967295, 4294967295, 1, 58, 32, 736, 1, 4294967295, 4294967295, 3, 58, 8, 737, 4, 580, 4294967295, 8, 58, 8, 741, 1, 4294967295, 4294967295, 1, 59, 32, 742, 1, 4294967295, 4294967295, 1, 59, 8, 743, 1, 4294967295, 4294967295, 3, 59, 8, 744, 2, 584, 4294967295, 8, 59, 8, 746, 1, 4294967295, 4294967295, 1, 59, 8, 747, 1, 4294967295, 4294967295, 5, 59, 8, 748, 1, 587, 4294967295, 8, 59, 8, 749, 1, 4294967295, 4294967295, 10, 59, 8, 750, 2, 4294967295, 4294967295, 12, 59, 8, 752, 1, 4294967295, 590, 9, 59, 8, 753, 1, 4294967295, 4294967295, 1, 59, 32, 754, 1, 4294967295, 4294967295, 3, 59, 8, 755, 2, 593, 4294967295, 8, 59, 8, 757, 1, 4294967295, 4294967295, 1, 59, 8, 758, 1, 4294967295, 4294967295, 1, 59, 32, 759, 1, 4294967295, 4294967295, 1, 59, 8, 760, 1, 4294967295, 4294967295, 1, 60, 32, 761, 1, 4294967295, 4294967295, 1, 60, 8, 762, 1, 4294967295, 4294967295, 3, 60, 8, 763, 2, 600, 4294967295, 8, 60, 8, 765, 1, 4294967295, 4294967295, 1, 60, 8, 766, 1, 4294967295, 4294967295, 3, 60, 8, 767, 2, 603, 4294967295, 8, 60, 8, 769, 1, 4294967295, 4294967295, 1, 61, 32, 770, 1, 4294967295, 4294967295, 1, 61, 32, 771, 1, 4294967295, 4294967295, 1, 61, 32, 772, 1, 4294967295, 4294967295, 1, 61, 8, 773, 1, 4294967295, 4294967295, 1, 62, 32, 774, 1, 4294967295, 4294967295, 1, 62, 8, 775, 1, 4294967295, 4294967295, 3, 62, 8, 776, 2, 611, 4294967295, 8, 62, 8, 778, 1, 4294967295, 4294967295, 1, 62, 32, 779, 1, 4294967295, 4294967295, 1, 62, 8, 780, 1, 4294967295, 4294967295, 3, 62, 8, 781, 2, 615, 4294967295, 8, 62, 8, 783, 1, 4294967295, 4294967295, 3, 62, 8, 784, 2, 617, 4294967295, 8, 62, 8, 786, 1, 4294967295, 4294967295, 1, 63, 32, 787, 1, 4294967295, 4294967295, 1, 63, 8, 788, 1, 4294967295, 4294967295, 1, 63, 32, 789, 1, 4294967295, 4294967295, 1, 63, 8, 790, 1, 4294967295, 4294967295, 5, 63, 8, 791, 1, 623, 4294967295, 8, 63, 8, 792, 1, 4294967295, 4294967295, 10, 63, 8, 793, 2, 4294967295, 4294967295, 12, 63, 8, 795, 1, 4294967295, 626, 9, 63, 8, 796, 1, 4294967295, 4294967295, 1, 63, 32, 797, 1, 4294967295, 4294967295, 1, 63, 8, 798, 1, 4294967295, 4294967295, 1, 64, 8, 799, 1, 4294967295, 4294967295, 1, 64, 8, 800, 1, 4294967295, 4294967295, 1, 64, 32, 801, 1, 4294967295, 4294967295, 1, 64, 8, 802, 1, 4294967295, 4294967295, 1, 64, 32, 803, 1, 4294967295, 4294967295, 1, 64, 32, 804, 1, 4294967295, 4294967295, 3, 64, 8, 805, 3, 636, 4294967295, 8, 64, 8, 808, 1, 4294967295, 4294967295, 3, 64, 8, 809, 2, 638, 4294967295, 8, 64, 8, 811, 1, 4294967295, 4294967295, 1, 65, 32, 812, 1, 4294967295, 4294967295, 1, 65, 8, 813, 1, 4294967295, 4294967295, 1, 66, 8, 814, 1, 4294967295, 4294967295, 1, 66, 32, 815, 1, 4294967295, 4294967295, 1, 66, 8, 816, 1, 4294967295, 4294967295, 5, 66, 8, 817, 1, 645, 4294967295, 8, 66, 8, 818, 1, 4294967295, 4294967295, 10, 66, 8, 819, 2, 4294967295, 4294967295, 12, 66, 8, 821, 1, 4294967295, 648, 9, 66, 8, 822, 1, 4294967295, 4294967295, 1, 66, 0, 823, 0, 4294967295, 4294967295, 1, 134, 0, 0, 0, 1, 150, 0, 0, 0, 1, 138, 0, 0, 0, 1, 159, 0, 0, 0, 1, 151, 0, 0, 0, 1, 166, 0, 0, 0, 1, 137, 0, 0, 0, 1, 168, 0, 0, 0, 1, 167, 0, 0, 0, 1, 327, 0, 0, 0, 1, 375, 0, 0, 0, 1, 584, 0, 0, 0, 1, 179, 0, 0, 0, 1, 170, 0, 0, 0, 1, 194, 0, 0, 0, 1, 182, 0, 0, 0, 1, 196, 0, 0, 0, 1, 167, 0, 0, 0, 1, 212, 0, 0, 0, 1, 202, 0, 0, 0, 1, 201, 0, 0, 0, 1, 214, 0, 0, 0, 1, 167, 0, 0, 0, 1, 220, 0, 0, 0, 1, 167, 0, 0, 0, 1, 226, 0, 0, 0, 1, 217, 0, 0, 0, 1, 223, 0, 0, 0, 1, 237, 0, 0, 0, 1, 167, 0, 0, 0, 1, 249, 0, 0, 0, 1, 239, 0, 0, 0, 1, 251, 0, 0, 0, 1, 195, 0, 0, 0, 1, 245, 0, 0, 0, 1, 320, 0, 0, 0, 1, 323, 0, 0, 0, 1, 346, 0, 0, 0, 1, 415, 0, 0, 0, 1, 480, 0, 0, 0, 1, 505, 0, 0, 0, 1, 253, 0, 0, 0, 1, 287, 0, 0, 0, 1, 319, 0, 0, 0, 1, 330, 0, 0, 0, 1, 342, 0, 0, 0, 1, 600, 0, 0, 0, 1, 262, 0, 0, 0, 1, 144, 0, 0, 0, 1, 274, 0, 0, 0, 1, 145, 0, 0, 0, 1, 279, 0, 0, 0, 1, 273, 0, 0, 0, 1, 282, 0, 0, 0, 1, 280, 0, 0, 0, 1, 311, 0, 0, 0, 1, 307, 0, 0, 0, 1, 317, 0, 0, 0, 1, 310, 0, 0, 0, 1, 321, 0, 0, 0, 1, 316, 0, 0, 0, 1, 326, 0, 0, 0, 1, 299, 0, 0, 0, 1, 328, 0, 0, 0, 1, 290, 0, 0, 0, 1, 331, 0, 0, 0, 1, 293, 0, 0, 0, 1, 340, 0, 0, 0, 1, 296, 0, 0, 0, 1, 343, 0, 0, 0, 1, 327, 0, 0, 0, 1, 587, 0, 0, 0, 1, 348, 0, 0, 0, 1, 283, 0, 0, 0, 1, 352, 0, 0, 0, 1, 349, 0, 0, 0, 1, 354, 0, 0, 0, 1, 305, 0, 0, 0, 1, 356, 0, 0, 0, 1, 355, 0, 0, 0, 1, 364, 0, 0, 0, 1, 361, 0, 0, 0, 1, 360, 0, 0, 0, 1, 370, 0, 0, 0, 1, 267, 0, 0, 0, 1, 280, 0, 0, 0, 1, 380, 0, 0, 0, 1, 378, 0, 0, 0, 1, 382, 0, 0, 0, 1, 381, 0, 0, 0, 1, 421, 0, 0, 0, 1, 395, 0, 0, 0, 1, 387, 0, 0, 0, 1, 386, 0, 0, 0, 1, 403, 0, 0, 0, 1, 392, 0, 0, 0, 1, 417, 0, 0, 0, 1, 399, 0, 0, 0, 1, 419, 0, 0, 0, 1, 411, 0, 0, 0, 1, 423, 0, 0, 0, 1, 393, 0, 0, 0, 1, 438, 0, 0, 0, 1, 429, 0, 0, 0, 1, 428, 0, 0, 0, 1, 442, 0, 0, 0, 1, 433, 0, 0, 0, 1, 439, 0, 0, 0, 1, 446, 0, 0, 0, 1, 435, 0, 0, 0, 1, 448, 0, 0, 0, 1, 595, 0, 0, 0, 1, 465, 0, 0, 0, 1, 367, 0, 0, 0, 1, 453, 0, 0, 0, 1, 452, 0, 0, 0, 1, 485, 0, 0, 0, 1, 461, 0, 0, 0, 1, 487, 0, 0, 0, 1, 484, 0, 0, 0, 1, 506, 0, 0, 0, 1, 493, 0, 0, 0, 1, 492, 0, 0, 0, 1, 508, 0, 0, 0, 1, 470, 0, 0, 0, 1, 514, 0, 0, 0, 1, 486, 0, 0, 0, 1, 518, 0, 0, 0, 1, 517, 0, 0, 0, 1, 532, 0, 0, 0, 1, 408, 0, 0, 0, 1, 412, 0, 0, 0, 1, 471, 0, 0, 0, 1, 476, 0, 0, 0, 1, 519, 0, 0, 0, 1, 540, 0, 0, 0, 1, 407, 0, 0, 0, 1, 546, 0, 0, 0, 1, 475, 0, 0, 0, 1, 513, 0, 0, 0, 1, 548, 0, 0, 0, 1, 541, 0, 0, 0, 1, 547, 0, 0, 0, 1, 556, 0, 0, 0, 1, 541, 0, 0, 0, 1, 547, 0, 0, 0, 1, 558, 0, 0, 0, 1, 557, 0, 0, 0, 1, 579, 0, 0, 0, 1, 557, 0, 0, 0, 1, 564, 0, 0, 0, 1, 563, 0, 0, 0, 1, 581, 0, 0, 0, 1, 513, 0, 0, 0, 1, 516, 0, 0, 0, 1, 597, 0, 0, 0, 1, 547, 0, 0, 0, 1, 604, 0, 0, 0, 1, 541, 0, 0, 0, 1, 580, 0, 0, 0, 1, 616, 0, 0, 0, 1, 541, 0, 0, 0, 1, 547, 0, 0, 0, 1, 618, 0, 0, 0, 1, 458, 0, 0, 0, 1, 551, 0, 0, 0, 1, 572, 0, 0, 0, 1, 576, 0, 0, 0, 1, 603, 0, 0, 0, 1, 611, 0, 0, 0, 1, 615, 0, 0, 0, 1, 637, 0, 0, 0, 1, 507, 0, 0, 0, 1, 624, 0, 0, 0, 1, 623, 0, 0, 0, 1, 639, 0, 0, 0, 1, 152, 0, 0, 0, 1, 180, 0, 0, 0, 1, 188, 0, 0, 0, 1, 187, 0, 0, 0, 1, 208, 0, 0, 0, 1, 210, 0, 0, 0, 1, 213, 0, 0, 0, 1, 231, 0, 0, 0, 1, 230, 0, 0, 0, 1, 244, 0, 0, 0, 1, 250, 0, 0, 0, 1, 264, 0, 0, 0, 1, 345, 0, 0, 0, 1, 368, 0, 0, 0, 1, 443, 0, 0, 0, 1, 447, 0, 0, 0, 1, 500, 0, 0, 0, 1, 509, 0, 0, 0, 1, 631, 0, 0, 0, 1, 646, 0, 0, 0, 1, 645, 0, 0, 0, 1, 641, 0, 0, 0, 1, 337, 0, 0, 0, 1, 336, 0, 0, 0, 1, 638, 0, 0, 0, 1, 636, 0, 0, 0, 3, 2, 1, 138, 0, 3, 6, 3, 137, 0, 1, 135, 0, 0, 0, 1, 140, 0, 0, 0, 1, 136, 0, 0, 0, 1, 139, 0, 0, 0, 1, 141, 0, 0, 0, 1, 138, 0, 0, 0, 3, 34, 17, 145, 0, 3, 32, 16, 144, 0, 1, 142, 0, 0, 0, 1, 147, 0, 0, 0, 1, 143, 0, 0, 0, 1, 146, 0, 0, 0, 1, 148, 0, 0, 0, 1, 145, 0, 0, 0, 5, 149, 4294967295, 0, 0, 1, 1, 0, 0, 0, 3, 4, 2, 151, 0, 3, 130, 65, 152, 0, 5, 153, 56, 0, 0, 1, 3, 0, 0, 0, 5, 155, 41, 0, 0, 5, 160, 43, 0, 0, 5, 157, 42, 0, 0, 5, 160, 43, 0, 0, 5, 160, 43, 0, 0, 1, 154, 0, 0, 0, 1, 156, 0, 0, 0, 1, 158, 0, 0, 0, 1, 5, 0, 0, 0, 3, 8, 4, 167, 0, 3, 14, 7, 167, 0, 3, 18, 9, 167, 0, 3, 20, 10, 167, 0, 3, 24, 12, 167, 0, 1, 161, 0, 0, 0, 1, 162, 0, 0, 0, 1, 163, 0, 0, 0, 1, 164, 0, 0, 0, 1, 165, 0, 0, 0, 1, 7, 0, 0, 0, 5, 174, 36, 0, 0, 3, 10, 5, 170, 0, 5, 171, 56, 0, 0, 1, 173, 0, 0, 0, 1, 169, 0, 0, 0, 1, 176, 0, 0, 0, 1, 172, 0, 0, 0, 1, 175, 0, 0, 0, 1, 177, 0, 0, 0, 1, 174, 0, 0, 0, 5, 178, 59, 0, 0, 1, 9, 0, 0, 0, 3, 130, 65, 180, 0, 5, 181, 7, 0, 0, 3, 12, 6, 182, 0, 1, 11, 0, 0, 0, 3, 130, 65, 188, 0, 5, 185, 70, 0, 0, 3, 130, 65, 187, 0, 1, 184, 0, 0, 0, 1, 190, 0, 0, 0, 1, 186, 0, 0, 0, 1, 189, 0, 0, 0, 1, 195, 0, 0, 0, 1, 188, 0, 0, 0, 5, 195, 11, 0, 0, 3, 28, 14, 195, 0, 5, 195, 33, 0, 0, 1, 183, 0, 0, 0, 1, 191, 0, 0, 0, 1, 192, 0, 0, 0, 1, 193, 0, 0, 0, 1, 13, 0, 0, 0, 5, 197, 39, 0, 0, 3, 16, 8, 202, 0, 5, 199, 55, 0, 0, 3, 16, 8, 201, 0, 1, 198, 0, 0, 0, 1, 204, 0, 0, 0, 1, 200, 0, 0, 0, 1, 203, 0, 0, 0, 1, 205, 0, 0, 0, 1, 202, 0, 0, 0, 5, 206, 56, 0, 0, 1, 15, 0, 0, 0, 3, 130, 65, 208, 0, 5, 209, 7, 0, 0, 3, 130, 65, 210, 0, 1, 213, 0, 0, 0, 3, 130, 65, 213, 0, 1, 207, 0, 0, 0, 1, 211, 0, 0, 0, 1, 17, 0, 0, 0, 5, 216, 37, 0, 0, 3, 22, 11, 217, 0, 1, 215, 0, 0, 0, 1, 217, 0, 0, 0, 1, 218, 0, 0, 0, 5, 219, 59, 0, 0, 1, 19, 0, 0, 0, 5, 222, 38, 0, 0, 3, 22, 11, 223, 0, 1, 221, 0, 0, 0, 1, 223, 0, 0, 0, 1, 224, 0, 0, 0, 5, 225, 59, 0, 0, 1, 21, 0, 0, 0, 3, 130, 65, 231, 0, 5, 228, 55, 0, 0, 3, 130, 65, 230, 0, 1, 227, 0, 0, 0, 1, 233, 0, 0, 0, 1, 229, 0, 0, 0, 1, 232, 0, 0, 0, 1, 235, 0, 0, 0, 1, 231, 0, 0, 0, 5, 236, 55, 0, 0, 1, 234, 0, 0, 0, 1, 236, 0, 0, 0, 1, 23, 0, 0, 0, 5, 241, 71, 0, 0, 3, 26, 13, 239, 0, 5, 240, 54, 0, 0, 1, 242, 0, 0, 0, 1, 238, 0, 0, 0, 1, 242, 0, 0, 0, 1, 243, 0, 0, 0, 3, 130, 65, 244, 0, 3, 28, 14, 245, 0, 1, 25, 0, 0, 0, 3, 130, 65, 250, 0, 5, 250, 41, 0, 0, 5, 250, 42, 0, 0, 1, 246, 0, 0, 0, 1, 247, 0, 0, 0, 1, 248, 0, 0, 0, 1, 27, 0, 0, 0, 5, 252, 4, 0, 0, 1, 29, 0, 0, 0, 5, 257, 35, 0, 0, 5, 256, 77, 0, 0, 1, 254, 0, 0, 0, 1, 259, 0, 0, 0, 1, 258, 0, 0, 0, 1, 255, 0, 0, 0, 1, 260, 0, 0, 0, 1, 257, 0, 0, 0, 5, 261, 75, 0, 0, 1, 31, 0, 0, 0, 5, 263, 52, 0, 0, 3, 130, 65, 264, 0, 5, 268, 56, 0, 0, 3, 66, 33, 267, 0, 1, 265, 0, 0, 0, 1, 270, 0, 0, 0, 1, 266, 0, 0, 0, 1, 269, 0, 0, 0, 1, 33, 0, 0, 0, 1, 268, 0, 0, 0, 3, 36, 18, 273, 0, 1, 271, 0, 0, 0, 1, 276, 0, 0, 0, 1, 272, 0, 0, 0, 1, 275, 0, 0, 0, 1, 35, 0, 0, 0, 1, 274, 0, 0, 0, 3, 38, 19, 280, 0, 3, 66, 33, 280, 0, 1, 277, 0, 0, 0, 1, 278, 0, 0, 0, 1, 37, 0, 0, 0, 3, 56, 28, 283, 0, 1, 281, 0, 0, 0, 1, 283, 0, 0, 0, 1, 284, 0, 0, 0, 5, 286, 9, 0, 0, 3, 30, 15, 287, 0, 1, 285, 0, 0, 0, 1, 287, 0, 0, 0, 1, 289, 0, 0, 0, 3, 48, 24, 290, 0, 1, 288, 0, 0, 0, 1, 290, 0, 0, 0, 1, 292, 0, 0, 0, 3, 50, 25, 293, 0, 1, 291, 0, 0, 0, 1, 293, 0, 0, 0, 1, 295, 0, 0, 0, 3, 52, 26, 296, 0, 1, 294, 0, 0, 0, 1, 296, 0, 0, 0, 1, 300, 0, 0, 0, 3, 46, 23, 299, 0, 1, 297, 0, 0, 0, 1, 302, 0, 0, 0, 1, 298, 0, 0, 0, 1, 301, 0, 0, 0, 1, 303, 0, 0, 0, 1, 300, 0, 0, 0, 5, 304, 53, 0, 0, 3, 60, 30, 305, 0, 5, 306, 56, 0, 0, 3, 40, 20, 307, 0, 1, 39, 0, 0, 0, 3, 42, 21, 310, 0, 1, 308, 0, 0, 0, 1, 313, 0, 0, 0, 1, 309, 0, 0, 0, 1, 312, 0, 0, 0, 1, 315, 0, 0, 0, 1, 311, 0, 0, 0, 3, 44, 22, 316, 0, 1, 314, 0, 0, 0, 1, 316, 0, 0, 0, 1, 41, 0, 0, 0, 5, 318, 50, 0, 0, 3, 30, 15, 319, 0, 3, 28, 14, 320, 0, 1, 43, 0, 0, 0, 5, 322, 51, 0, 0, 3, 28, 14, 323, 0, 1, 45, 0, 0, 0, 3, 8, 4, 327, 0, 3, 54, 27, 327, 0, 1, 324, 0, 0, 0, 1, 325, 0, 0, 0, 1, 47, 0, 0, 0, 5, 329, 47, 0, 0, 3, 30, 15, 330, 0, 1, 49, 0, 0, 0, 5, 332, 49, 0, 0, 3, 132, 66, 337, 0, 5, 334, 55, 0, 0, 3, 132, 66, 336, 0, 1, 333, 0, 0, 0, 1, 339, 0, 0, 0, 1, 335, 0, 0, 0, 1, 338, 0, 0, 0, 1, 51, 0, 0, 0, 1, 337, 0, 0, 0, 5, 341, 48, 0, 0, 3, 30, 15, 342, 0, 1, 53, 0, 0, 0, 5, 344, 71, 0, 0, 3, 130, 65, 345, 0, 3, 28, 14, 346, 0, 1, 55, 0, 0, 0, 3, 58, 29, 349, 0, 1, 347, 0, 0, 0, 1, 350, 0, 0, 0, 1, 348, 0, 0, 0, 1, 351, 0, 0, 0, 1, 57, 0, 0, 0, 7, 353, 0, 0, 0, 1, 59, 0, 0, 0, 3, 62, 31, 355, 0, 1, 61, 0, 0, 0, 3, 64, 32, 361, 0, 5, 358, 67, 0, 0, 3, 64, 32, 360, 0, 1, 357, 0, 0, 0, 1, 363, 0, 0, 0, 1, 359, 0, 0, 0, 1, 362, 0, 0, 0, 1, 63, 0, 0, 0, 1, 361, 0, 0, 0, 3, 90, 45, 367, 0, 5, 366, 72, 0, 0, 3, 130, 65, 368, 0, 1, 365, 0, 0, 0, 1, 368, 0, 0, 0, 1, 65, 0, 0, 0, 5, 371, 40, 0, 0, 1, 369, 0, 0, 0, 1, 371, 0, 0, 0, 1, 372, 0, 0, 0, 5, 374, 12, 0, 0, 3, 8, 4, 375, 0, 1, 373, 0, 0, 0, 1, 375, 0, 0, 0, 1, 376, 0, 0, 0, 5, 377, 53, 0, 0, 3, 68, 34, 378, 0, 5, 379, 56, 0, 0, 1, 67, 0, 0, 0, 3, 70, 35, 381, 0, 1, 69, 0, 0, 0, 3, 72, 36, 387, 0, 5, 384, 67, 0, 0, 3, 72, 36, 386, 0, 1, 383, 0, 0, 0, 1, 389, 0, 0, 0, 1, 385, 0, 0, 0, 1, 388, 0, 0, 0, 1, 71, 0, 0, 0, 1, 387, 0, 0, 0, 3, 74, 37, 392, 0, 3, 80, 40, 393, 0, 1, 391, 0, 0, 0, 1, 393, 0, 0, 0, 1, 396, 0, 0, 0, 1, 396, 0, 0, 0, 1, 390, 0, 0, 0, 1, 394, 0, 0, 0, 1, 73, 0, 0, 0, 3, 76, 38, 399, 0, 1, 397, 0, 0, 0, 1, 400, 0, 0, 0, 1, 398, 0, 0, 0, 1, 401, 0, 0, 0, 1, 404, 0, 0, 0, 1, 404, 0, 0, 0, 1, 398, 0, 0, 0, 1, 402, 0, 0, 0, 1, 75, 0, 0, 0, 3, 106, 53, 407, 0, 3, 104, 52, 408, 0, 1, 406, 0, 0, 0, 1, 408, 0, 0, 0, 1, 418, 0, 0, 0, 3, 78, 39, 411, 0, 3, 104, 52, 412, 0, 1, 410, 0, 0, 0, 1, 412, 0, 0, 0, 1, 418, 0, 0, 0, 3, 28, 14, 415, 0, 5, 416, 63, 0, 0, 1, 414, 0, 0, 0, 1, 416, 0, 0, 0, 1, 418, 0, 0, 0, 1, 405, 0, 0, 0, 1, 409, 0, 0, 0, 1, 413, 0, 0, 0, 1, 77, 0, 0, 0, 5, 420, 57, 0, 0, 3, 70, 35, 421, 0, 5, 422, 58, 0, 0, 1, 79, 0, 0, 0, 5, 424, 60, 0, 0, 3, 82, 41, 429, 0, 5, 426, 55, 0, 0, 3, 82, 41, 428, 0, 1, 425, 0, 0, 0, 1, 431, 0, 0, 0, 1, 427, 0, 0, 0, 1, 430, 0, 0, 0, 1, 81, 0, 0, 0, 1, 429, 0, 0, 0, 3, 84, 42, 433, 0, 5, 434, 57, 0, 0, 3, 86, 43, 435, 0, 5, 436, 58, 0, 0, 1, 439, 0, 0, 0, 3, 84, 42, 439, 0, 1, 432, 0, 0, 0, 1, 437, 0, 0, 0, 1, 83, 0, 0, 0, 3, 130, 65, 443, 0, 5, 443, 52, 0, 0, 1, 440, 0, 0, 0, 1, 441, 0, 0, 0, 1, 85, 0, 0, 0, 3, 130, 65, 447, 0, 5, 447, 33, 0, 0, 1, 444, 0, 0, 0, 1, 445, 0, 0, 0, 1, 87, 0, 0, 0, 3, 90, 45, 453, 0, 5, 450, 67, 0, 0, 3, 90, 45, 452, 0, 1, 449, 0, 0, 0, 1, 455, 0, 0, 0, 1, 451, 0, 0, 0, 1, 454, 0, 0, 0, 1, 89, 0, 0, 0, 1, 453, 0, 0, 0, 3, 126, 63, 458, 0, 1, 456, 0, 0, 0, 1, 458, 0, 0, 0, 1, 460, 0, 0, 0, 3, 92, 46, 461, 0, 1, 459, 0, 0, 0, 1, 462, 0, 0, 0, 1, 460, 0, 0, 0, 1, 463, 0, 0, 0, 1, 466, 0, 0, 0, 1, 466, 0, 0, 0, 1, 457, 0, 0, 0, 1, 464, 0, 0, 0, 1, 91, 0, 0, 0, 3, 98, 49, 470, 0, 3, 104, 52, 471, 0, 1, 471, 0, 0, 0, 1, 468, 0, 0, 0, 1, 469, 0, 0, 0, 1, 486, 0, 0, 0, 3, 108, 54, 475, 0, 3, 104, 52, 476, 0, 1, 476, 0, 0, 0, 1, 473, 0, 0, 0, 1, 474, 0, 0, 0, 1, 486, 0, 0, 0, 3, 100, 50, 486, 0, 3, 28, 14, 480, 0, 5, 481, 63, 0, 0, 1, 479, 0, 0, 0, 1, 481, 0, 0, 0, 1, 483, 0, 0, 0, 3, 94, 47, 484, 0, 1, 482, 0, 0, 0, 1, 484, 0, 0, 0, 1, 486, 0, 0, 0, 1, 467, 0, 0, 0, 1, 472, 0, 0, 0, 1, 477, 0, 0, 0, 1, 478, 0, 0, 0, 1, 93, 0, 0, 0, 5, 488, 61, 0, 0, 3, 96, 48, 493, 0, 5, 490, 55, 0, 0, 3, 96, 48, 492, 0, 1, 489, 0, 0, 0, 1, 495, 0, 0, 0, 1, 491, 0, 0, 0, 1, 494, 0, 0, 0, 1, 496, 0, 0, 0, 1, 493, 0, 0, 0, 5, 497, 62, 0, 0, 1, 95, 0, 0, 0, 3, 128, 64, 507, 0, 3, 130, 65, 500, 0, 5, 504, 7, 0, 0, 3, 28, 14, 505, 0, 5, 505, 33, 0, 0, 5, 505, 11, 0, 0, 1, 501, 0, 0, 0, 1, 502, 0, 0, 0, 1, 503, 0, 0, 0, 1, 507, 0, 0, 0, 1, 498, 0, 0, 0, 1, 499, 0, 0, 0, 1, 97, 0, 0, 0, 3, 130, 65, 509, 0, 7, 512, 1, 0, 0, 3, 108, 54, 513, 0, 3, 118, 59, 513, 0, 1, 510, 0, 0, 0, 1, 511, 0, 0, 0, 1, 99, 0, 0, 0, 3, 118, 59, 516, 0, 3, 102, 51, 517, 0, 1, 515, 0, 0, 0, 1, 517, 0, 0, 0, 1, 101, 0, 0, 0, 3, 104, 52, 519, 0, 1, 103, 0, 0, 0, 5, 522, 63, 0, 0, 5, 523, 63, 0, 0, 1, 521, 0, 0, 0, 1, 523, 0, 0, 0, 1, 533, 0, 0, 0, 5, 526, 64, 0, 0, 5, 527, 63, 0, 0, 1, 525, 0, 0, 0, 1, 527, 0, 0, 0, 1, 533, 0, 0, 0, 5, 530, 66, 0, 0, 5, 531, 63, 0, 0, 1, 529, 0, 0, 0, 1, 531, 0, 0, 0, 1, 533, 0, 0, 0, 1, 520, 0, 0, 0, 1, 524, 0, 0, 0, 1, 528, 0, 0, 0, 1, 105, 0, 0, 0, 3, 122, 61, 541, 0, 3, 124, 62, 541, 0, 5, 541, 9, 0, 0, 3, 112, 56, 541, 0, 5, 541, 8, 0, 0, 3, 110, 55, 541, 0, 1, 534, 0, 0, 0, 1, 535, 0, 0, 0, 1, 536, 0, 0, 0, 1, 537, 0, 0, 0, 1, 538, 0, 0, 0, 1, 539, 0, 0, 0, 1, 107, 0, 0, 0, 3, 124, 62, 547, 0, 3, 120, 60, 547, 0, 3, 112, 56, 547, 0, 3, 110, 55, 547, 0, 1, 542, 0, 0, 0, 1, 543, 0, 0, 0, 1, 544, 0, 0, 0, 1, 545, 0, 0, 0, 1, 109, 0, 0, 0, 5, 550, 70, 0, 0, 3, 126, 63, 551, 0, 1, 549, 0, 0, 0, 1, 551, 0, 0, 0, 1, 111, 0, 0, 0, 5, 553, 73, 0, 0, 3, 116, 58, 557, 0, 5, 555, 73, 0, 0, 3, 114, 57, 557, 0, 1, 552, 0, 0, 0, 1, 554, 0, 0, 0, 1, 113, 0, 0, 0, 5, 559, 57, 0, 0, 3, 116, 58, 564, 0, 5, 561, 67, 0, 0, 3, 116, 58, 563, 0, 1, 560, 0, 0, 0, 1, 566, 0, 0, 0, 1, 562, 0, 0, 0, 1, 565, 0, 0, 0, 1, 567, 0, 0, 0, 1, 564, 0, 0, 0, 5, 568, 58, 0, 0, 1, 115, 0, 0, 0, 5, 571, 12, 0, 0, 3, 126, 63, 572, 0, 1, 570, 0, 0, 0, 1, 572, 0, 0, 0, 1, 580, 0, 0, 0, 5, 575, 11, 0, 0, 3, 126, 63, 576, 0, 1, 574, 0, 0, 0, 1, 576, 0, 0, 0, 1, 580, 0, 0, 0, 3, 122, 61, 580, 0, 5, 580, 8, 0, 0, 1, 569, 0, 0, 0, 1, 573, 0, 0, 0, 1, 577, 0, 0, 0, 1, 578, 0, 0, 0, 1, 117, 0, 0, 0, 5, 592, 57, 0, 0, 3, 8, 4, 584, 0, 1, 582, 0, 0, 0, 1, 584, 0, 0, 0, 1, 588, 0, 0, 0, 3, 54, 27, 587, 0, 1, 585, 0, 0, 0, 1, 590, 0, 0, 0, 1, 586, 0, 0, 0, 1, 589, 0, 0, 0, 1, 591, 0, 0, 0, 1, 588, 0, 0, 0, 5, 593, 53, 0, 0, 1, 583, 0, 0, 0, 1, 593, 0, 0, 0, 1, 594, 0, 0, 0, 3, 88, 44, 595, 0, 5, 596, 58, 0, 0, 1, 119, 0, 0, 0, 5, 599, 9, 0, 0, 3, 30, 15, 600, 0, 1, 598, 0, 0, 0, 1, 600, 0, 0, 0, 1, 602, 0, 0, 0, 3, 126, 63, 603, 0, 1, 601, 0, 0, 0, 1, 603, 0, 0, 0, 1, 121, 0, 0, 0, 5, 605, 11, 0, 0, 5, 606, 69, 0, 0, 5, 607, 11, 0, 0, 1, 123, 0, 0, 0, 5, 610, 12, 0, 0, 3, 126, 63, 611, 0, 1, 609, 0, 0, 0, 1, 611, 0, 0, 0, 1, 617, 0, 0, 0, 5, 614, 11, 0, 0, 3, 126, 63, 615, 0, 1, 613, 0, 0, 0, 1, 615, 0, 0, 0, 1, 617, 0, 0, 0, 1, 608, 0, 0, 0, 1, 612, 0, 0, 0, 1, 125, 0, 0, 0, 5, 619, 61, 0, 0, 3, 128, 64, 624, 0, 5, 621, 55, 0, 0, 3, 128, 64, 623, 0, 1, 620, 0, 0, 0, 1, 626, 0, 0, 0, 1, 622, 0, 0, 0, 1, 625, 0, 0, 0, 1, 627, 0, 0, 0, 1, 624, 0, 0, 0, 5, 628, 62, 0, 0, 1, 127, 0, 0, 0, 3, 132, 66, 638, 0, 3, 130, 65, 631, 0, 5, 635, 7, 0, 0, 3, 132, 66, 636, 0, 5, 636, 11, 0, 0, 5, 636, 33, 0, 0, 1, 632, 0, 0, 0, 1, 633, 0, 0, 0, 1, 634, 0, 0, 0, 1, 638, 0, 0, 0, 1, 629, 0, 0, 0, 1, 630, 0, 0, 0, 1, 129, 0, 0, 0, 7, 640, 2, 0, 0, 1, 131, 0, 0, 0, 3, 130, 65, 646, 0, 5, 643, 70, 0, 0, 3, 130, 65, 645, 0, 1, 642, 0, 0, 0, 1, 648, 0, 0, 0, 1, 644, 0, 0, 0, 1, 647, 0, 0, 0, 1, 133, 0, 0, 0, 1, 646, 0, 0, 0, 0, 2, 1, 0, 2, 2, 2, 1, 2, 2, 4, 2, 1, 4, 2, 40, 40, 44, 46, 7, 7, 65, 65, 9, 9, 12, 12, 0, 28928, 0, 0, 128, 0, 2, 0, 4608, 0, 0, 0, 138, 145, 159, 166, 174, 188, 194, 202, 212, 216, 222, 231, 235, 241, 249, 257, 268, 274, 279, 282, 286, 289, 292, 295, 300, 311, 315, 326, 337, 350, 361, 367, 370, 374, 387, 392, 395, 400, 403, 407, 411, 415, 417, 429, 438, 442, 446, 453, 457, 462, 465, 470, 475, 480, 483, 485, 493, 504, 506, 512, 516, 522, 526, 530, 532, 540, 546, 550, 556, 564, 571, 575, 579, 583, 588, 592, 599, 602, 610, 614, 616, 624, 635, 637, 646, 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, 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];
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 AntlRv4ParserParseOutput<R, L>
where
    L: TokenSource,
{
    pub result: R,
    pub parser: AntlRv4Parser<L>,
}

impl<L: TokenSource> AntlRv4ParserParseOutput<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<ANTLRv4ValidatedTree, ANTLRv4ValidationError> {
        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(ANTLRv4ValidationError::SyntaxErrors { lexer, parser });
        }
        let parsed = self.parser.into_parsed_file(self.result);
        validate_tree_structure(&parsed)?;
        Ok(ANTLRv4ValidatedTree::__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, AntlRv4Parser::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 AntlRv4Parser<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 AntlRv4Parser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<ANTLRv4ValidatedTree, ANTLRv4ValidationError>
{
    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 `AntlRv4Parser::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 AntlRv4Parser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<AntlRv4ParserParseOutput<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 AntlRv4Parser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<antlr4_runtime::ParsedFile, antlr4_runtime::AntlrError>
{
    let AntlRv4ParserParseOutput { 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 AntlRv4Parser<L>) -> Result<antlr4_runtime::NodeId, antlr4_runtime::AntlrError>,
) -> Result<ANTLRv4ValidatedTree, ANTLRv4ValidationError>
{
    let output = parse_stream_with_parser(input, lexer, entry)
        .map_err(ANTLRv4ValidationError::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 AntlRv4Parser<L>) -> Result<R, antlr4_runtime::AntlrError>,
) -> Result<AntlRv4ParserParseOutput<R, L>, antlr4_runtime::AntlrError>
{
    let lexer = lexer(input);
    let tokens = CommonTokenStream::new(lexer);
    let mut parser = AntlRv4Parser::new(tokens);
    let result = entry(&mut parser)?;
    Ok(AntlRv4ParserParseOutput { 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:
/// - `grammar_spec()`
///
/// All parser rule methods:
/// - `grammar_spec()`
/// - `grammar_decl()`
/// - `grammar_type()`
/// - `prequel_construct()`
/// - `options_spec()`
/// - `option()`
/// - `option_value()`
/// - `delegate_grammars()`
/// - `delegate_grammar()`
/// - `tokens_spec()`
/// - `channels_spec()`
/// - `id_list()`
/// - `action()`
/// - `action_scope_name()`
/// - `action_block()`
/// - `arg_action_block()`
/// - `mode_spec()`
/// - `rules()`
/// - `rule_spec()`
/// - `parser_rule_spec()`
/// - `exception_group()`
/// - `exception_handler()`
/// - `finally_clause()`
/// - `rule_prequel()`
/// - `rule_returns()`
/// - `throws_spec()`
/// - `locals_spec()`
/// - `rule_action()`
/// - `rule_modifiers()`
/// - `rule_modifier()`
/// - `rule_block()`
/// - `rule_alt_list()`
/// - `labeled_alt()`
/// - `lexer_rule_spec()`
/// - `lexer_rule_block()`
/// - `lexer_alt_list()`
/// - `lexer_alt()`
/// - `lexer_elements()`
/// - `lexer_element()`
/// - `lexer_block()`
/// - `lexer_commands()`
/// - `lexer_command()`
/// - `lexer_command_name()`
/// - `lexer_command_expr()`
/// - `alt_list()`
/// - `alternative()`
/// - `element()`
/// - `predicate_options()`
/// - `predicate_option()`
/// - `labeled_element()`
/// - `ebnf()`
/// - `block_suffix()`
/// - `ebnf_suffix()`
/// - `lexer_atom()`
/// - `atom()`
/// - `wildcard()`
/// - `not_set()`
/// - `block_set()`
/// - `set_element()`
/// - `block()`
/// - `ruleref()`
/// - `character_range()`
/// - `terminal_def()`
/// - `element_options()`
/// - `element_option()`
/// - `identifier()`
/// - `qualified_identifier()`
#[derive(Debug)]
pub struct AntlRv4Parser<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,
}

#[allow(dead_code)]
#[derive(Debug)]
enum GeneratedRuleError {
    Fatal(antlr4_runtime::AntlrError),
    Interpreted(antlr4_runtime::AntlrError),
}

impl GeneratedRuleError {
    fn into_error(self) -> antlr4_runtime::AntlrError {
        match self {
            Self::Fatal(error) | Self::Interpreted(error) => error,
        }
    }
}
impl<L> AntlRv4Parser<L, antlr4_runtime::NoSemanticHooks>
where
    L: TokenSource,
{
    pub fn new(input: CommonTokenStream<L>) -> Self {
        Self::with_hooks(input, antlr4_runtime::NoSemanticHooks)
    }
}

impl<L, H> AntlRv4Parser<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(),
        }
    }

    #[allow(dead_code)]
    fn parse_rule(&mut self, rule_index: usize) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence(rule_index, 0)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence_inner(rule_index, precedence, true)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence_from_generated(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule_precedence_inner(rule_index, precedence, false)
    }

    #[allow(dead_code)]
    fn parse_rule_precedence_inner(&mut self, rule_index: usize, precedence: i32, allow_generated_fallback: bool) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        if allow_generated_fallback {
            // True top-level entry: drop any fail-loud coordinates left by a
            // previous parse so a reused parser starts clean. Mid-parse the hits
            // are preserved so a generated parent can surface a recovered child's
            // fail-loud coordinate at this boundary.
            self.base.reset_unknown_semantic_hits();
            // Likewise drop stale sticky aborts (depth-cap violation,
            // parse-listener abort): entry rules share one parser instance,
            // and the flags must not poison the next parse when the previous
            // one exited through an error path.
            let _ = self.base.take_parse_abort();
        }
        let __rule_start = antlr4_runtime::IntStream::index(self.base.input());
        let __generated_only = self.generated_only();
        let __tree = if let Some(result) = self.parse_generated_rule(rule_index, precedence, allow_generated_fallback) {
            match result {
                Ok(tree) => tree,
                Err(error) => {
                    antlr4_runtime::IntStream::seek(self.base.input(), __rule_start);
                    let __report_error =
                        matches!(&error, GeneratedRuleError::Fatal(_));
                    // A fatal unwind retains recovery diagnostics committed
                    // earlier in this entry. Dispatch them before a semantic
                    // or parser-abort override can return, or they would leak
                    // into the next entry on a reused parser.
                    if allow_generated_fallback && __report_error {
                        self.base.report_generated_parser_diagnostics();
                    }
                    if allow_generated_fallback {
                        // A sticky abort (depth cap, listener) wins over an
                        // error or semantic miss derived after recovery absorbed
                        // the aborted rule. Drain any masked semantic miss too,
                        // so neither condition poisons the next entry.
                        if let Some(abort) = self.base.take_parse_abort() {
                            let _ = self.base.take_unknown_semantic_error();
                            return Err(abort);
                        }
                        // A generated predicate that consulted an unimplemented
                        // hook fails the alternative and surfaces here as a generic
                        // failed-predicate/rule error. Prefer the recorded fail-loud
                        // semantic error when no parser abort occurred.
                        if let Some(semantic_error) = self.base.take_unknown_semantic_error() {
                            return Err(semantic_error);
                        }
                    }
                    let error = error.into_error();
                    if allow_generated_fallback && __report_error {
                        self.base.report_unrecovered_parser_error(&error);
                    }
                    return Err(error);
                }
            }
        } else if __generated_only {
            return Err(antlr4_runtime::AntlrError::Unsupported(format!("generated parser did not emit rule {}", rule_index)));
        } else {
            self.parse_interpreted_rule_precedence(rule_index, precedence)?
        };
        if allow_generated_fallback {
            self.base.report_generated_parser_diagnostics();
            // A sticky abort (depth-cap violation, listener abort) is not a
            // syntax error: rule-level recovery may have produced a tree
            // and semantic miss anyway, but the abort is the root cause. Drain
            // both sticky conditions before returning so parser reuse is clean.
            if let Some(error) = self.base.take_parse_abort() {
                let _ = self.base.take_unknown_semantic_error();
                return Err(error);
            }
            // Surface unknown predicate/action coordinates recorded under the
            // Error policy only after parser aborts have been ruled out.
            if let Some(error) = self.base.take_unknown_semantic_error() {
                return Err(error);
            }
        }
        Ok(__tree)
    }

    #[allow(dead_code)]
    fn parse_interpreted_rule(&mut self, rule_index: usize) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_interpreted_rule_precedence(rule_index, 0)
    }

    #[allow(dead_code)]
    fn parse_interpreted_rule_precedence(&mut self, rule_index: usize, precedence: i32) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        if precedence == 0 && false && std::env::var_os("ANTLR4_RUST_ADAPTIVE_DIRECT").is_some() {
            let simulator = self
                .simulator
                .get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
            self.base
                .parse_atn_rule_adaptive_or_fallback(atn(), simulator, rule_index)
        } else {
        let (tree, actions) = self.base.parse_atn_rule_with_runtime_options_and_precedence(atn(), rule_index, precedence, antlr4_runtime::ParserRuntimeOptions { action_indices: &[], track_alt_numbers: false, track_context_alt_numbers: false, predicates: &[], semantics: Some(parser_semantics()), rule_args: &[], member_actions: &[], return_actions: &[], unknown_predicate_policy: antlr4_runtime::UnknownSemanticPolicy::Error , ..antlr4_runtime::ParserRuntimeOptions::default() })?;
        let _ = actions;
        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)),
            _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 134isize, self.parse_generated_rule_1_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_138 = false;
                loop {
                    self.base.sync_into(atn(), 138, &mut __ctx, __loop_iter_138, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        36..=39 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 9 | 12 | 40 | 44..=46 | 52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 138, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_138 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 135isize, self.parse_generated_rule_3_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 141isize, self.parse_generated_rule_17_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_145 = false;
                loop {
                    self.base.sync_into(atn(), 145, &mut __ctx, __loop_iter_145, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        52 => 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(), 145, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_145 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 142isize, self.parse_generated_rule_16_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(-1, 149, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 150isize, self.parse_generated_rule_2_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 151isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(56, 153, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            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) {
                    41 => 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 },
                    43 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 159, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            41 => 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 },
                            43 => 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(), 159, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(41, 155, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.match_token_into(43, 160, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                        self.base.match_token_into(42, 157, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.match_token_into(43, 160, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    3 => {
                        self.base.match_token_into(43, 160, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 [none];
            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) {
                    36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    71 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 166, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            39 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            37 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            38 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            71 => 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(), 166, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 161isize, self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 162isize, self.parse_generated_rule_7_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 163isize, self.parse_generated_rule_9_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    4 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 164isize, self.parse_generated_rule_10_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    5 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 165isize, self.parse_generated_rule_12_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(36, 174, atn(), &mut __ctx, &mut __consumed_eof)?;
                let mut __loop_iter_174 = false;
                loop {
                    self.base.sync_into(atn(), 174, &mut __ctx, __loop_iter_174, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 174, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_174 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 169isize, self.parse_generated_rule_5_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            self.base.match_token_into(56, 171, atn(), &mut __ctx, &mut __consumed_eof)?;
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(59, 178, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 179isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(7, 181, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 181isize, self.parse_generated_rule_6_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            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) {
                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 194, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            33 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 194, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 183isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        let mut __loop_iter_188 = false;
                        loop {
                            self.base.sync_into(atn(), 188, &mut __ctx, __loop_iter_188, &mut __sync_error)?;
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                56 => 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(), 188, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_188 = true;
                                    self.base.match_token_into(70, 185, atn(), &mut __ctx, &mut __consumed_eof)?;
                                    antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 185isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                        self.base.match_token_into(11, 195, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 192isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    4 => {
                        self.base.match_token_into(33, 195, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(39, 197, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 197isize, self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_202 = false;
                loop {
                    self.base.sync_into(atn(), 202, &mut __ctx, __loop_iter_202, &mut __sync_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 },
                        56 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 202, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_202 = true;
                            self.base.match_token_into(55, 199, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 199isize, self.parse_generated_rule_8_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(56, 206, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 212, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 212) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(8, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(8, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 212, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 207isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(7, 209, atn(), &mut __ctx, &mut __consumed_eof)?;
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 209isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 211isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_9(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 18isize, 9, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(37, 216, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 216, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 216, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 215isize, self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.match_token_into(59, 219, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(38, 222, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 222, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    59 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 222, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 221isize, self.parse_generated_rule_11_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.match_token_into(59, 225, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 226isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_231 = false;
                loop {
                    self.base.sync_into(atn(), 231, &mut __ctx, __loop_iter_231, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 231) {
                        __prediction
                    } else {
                        let __prediction = {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            __simulator.adaptive_predict_stream_info_sll_probe(11, 0, self.base.input())
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        };
                        if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                            let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                            let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                            __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                            __simulator.adaptive_predict_stream_info_with_context(11, 0, self.base.input(), __prediction_context)
                                .map_err(|__error| match __error {
                                    antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                    _ => self.base.no_viable_alternative_error(__decision_start),
                                })?
                        } else {
                            __prediction
                        }
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 231, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_231 = true;
                            self.base.match_token_into(55, 228, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 228isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.sync_into(atn(), 235, &mut __ctx, false, &mut __sync_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 },
                    59 => 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(), 235, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(55, 236, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(71, 241, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 241, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 241) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(13, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(13, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 241, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 238isize, self.parse_generated_rule_13_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(54, 240, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 243isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 244isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            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) {
                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    42 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 249, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            41 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            42 => 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(), 249, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 246isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        self.base.match_token_into(41, 250, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    3 => {
                        self.base.match_token_into(42, 250, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(4, 252, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(35, 257, atn(), &mut __ctx, &mut __consumed_eof)?;
                let mut __loop_iter_257 = false;
                loop {
                    self.base.sync_into(atn(), 257, &mut __ctx, __loop_iter_257, &mut __sync_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(15, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 257, &__prediction);
                    match __prediction.alt {
                        2 => {
                            __loop_iter_257 = true;
                            self.base.match_token_into(77, 256, atn(), &mut __ctx, &mut __consumed_eof)?;
                        }
                        1 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(75, 261, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(52, 263, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 263isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(56, 268, atn(), &mut __ctx, &mut __consumed_eof)?;
                let mut __loop_iter_268 = false;
                loop {
                    self.base.sync_into(atn(), 268, &mut __ctx, __loop_iter_268, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        12 | 40 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 52 => 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(), 268, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_268 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 265isize, self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_17(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 34isize, 17, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_274 = false;
                loop {
                    self.base.sync_into(atn(), 274, &mut __ctx, __loop_iter_274, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        9 | 12 | 40 | 44..=46 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        -1 | 52 => 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(), 274, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_274 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 271isize, self.parse_generated_rule_18_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_18(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 36isize, 18, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            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) {
                    9 | 44..=46 => 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 },
                    _ => {
                        self.base.sync_into(atn(), 279, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 279) {
                            __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(18, 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(18, 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(), 279, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 277isize, self.parse_generated_rule_19_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 278isize, self.parse_generated_rule_33_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 282, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    40 | 44..=46 => 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 },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 282, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 281isize, self.parse_generated_rule_28_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.match_token_into(9, 286, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 286, &mut __ctx, false, &mut __sync_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 },
                    36 | 47..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 286, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 285isize, self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.sync_into(atn(), 289, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    47 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    36 | 48..=49 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 289, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 288isize, self.parse_generated_rule_24_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.sync_into(atn(), 292, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    49 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    36 | 48 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 292, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 291isize, self.parse_generated_rule_25_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.sync_into(atn(), 295, &mut __ctx, false, &mut __sync_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 },
                    36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 295, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 294isize, self.parse_generated_rule_26_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                let mut __loop_iter_300 = false;
                loop {
                    self.base.sync_into(atn(), 300, &mut __ctx, __loop_iter_300, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        36 | 71 => 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(), 300, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_300 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 297isize, self.parse_generated_rule_23_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(53, 304, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 304isize, self.parse_generated_rule_30_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(56, 306, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 306isize, self.parse_generated_rule_20_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                let mut __loop_iter_311 = false;
                loop {
                    self.base.sync_into(atn(), 311, &mut __ctx, __loop_iter_311, &mut __sync_error)?;
                    let __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 },
                        -1 | 9 | 12 | 40 | 44..=46 | 51..=52 => 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(), 311, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_311 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 308isize, self.parse_generated_rule_21_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.sync_into(atn(), 315, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    51 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    -1 | 9 | 12 | 40 | 44..=46 | 52 => 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(), 315, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 314isize, self.parse_generated_rule_22_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(50, 318, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 318isize, self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 319isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(51, 322, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 322isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            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) {
                    36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 326, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 326, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 324isize, self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 325isize, self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(47, 329, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 329isize, self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(49, 332, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 332isize, self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_337 = false;
                loop {
                    self.base.sync_into(atn(), 337, &mut __ctx, __loop_iter_337, &mut __sync_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 },
                        36 | 48 | 53 | 71 => 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(), 337, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_337 = true;
                            self.base.match_token_into(55, 334, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 334isize, self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(48, 341, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 341isize, self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(71, 344, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 344isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 345isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 347isize, self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_350 = true;
                loop {
                    self.base.sync_into(atn(), 350, &mut __ctx, __loop_iter_350, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        40 | 44..=46 => 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 },
                        _ => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 350, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_350 = true;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 347isize, self.parse_generated_rule_29_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_set_into(&[(40, 40), (44, 46)], 353, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 354isize, self.parse_generated_rule_31_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 356isize, self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_361 = false;
                loop {
                    self.base.sync_into(atn(), 361, &mut __ctx, __loop_iter_361, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        56 => 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(), 361, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_361 = true;
                            self.base.match_token_into(67, 358, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 358isize, self.parse_generated_rule_32_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 364isize, self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.sync_into(atn(), 367, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    72 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    56 | 67 => 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(), 367, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(72, 366, atn(), &mut __ctx, &mut __consumed_eof)?;
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 366isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 370, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    40 => 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(), 370, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(40, 371, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.match_token_into(12, 374, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 374, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    36 => 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(), 374, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 373isize, self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.match_token_into(53, 377, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 377isize, self.parse_generated_rule_34_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(56, 379, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 380isize, self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 382isize, self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_387 = false;
                loop {
                    self.base.sync_into(atn(), 387, &mut __ctx, __loop_iter_387, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        56 | 58 => 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(), 387, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_387 = true;
                            self.base.match_token_into(67, 384, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 384isize, self.parse_generated_rule_36_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 395, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 395) {
                    __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(36, 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(36, 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(), 395, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 390isize, self.parse_generated_rule_37_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 392, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            60 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            56 | 58 | 67 => 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(), 392, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 391isize, self.parse_generated_rule_40_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_37(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 74isize, 37, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 403, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    56 | 58 | 60 | 67 => 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(), 403, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 397isize, self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        let mut __loop_iter_400 = true;
                        loop {
                            self.base.sync_into(atn(), 400, &mut __ctx, __loop_iter_400, &mut __sync_error)?;
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                4 | 8..=9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                56 | 58 | 60 | 67 => 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(), 400, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_400 = true;
                                    antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 397isize, self.parse_generated_rule_38_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => 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 [none];
            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) {
                    8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 417, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            8..=9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 => 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(), 417, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 405isize, self.parse_generated_rule_53_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 407, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => 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(), 407, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 406isize, self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 409isize, self.parse_generated_rule_39_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 411, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => 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(), 411, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 410isize, self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 413isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 415, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 73 => 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(), 415, &__prediction);
                        match __prediction.alt {
                            1 => {
                                self.base.match_token_into(63, 416, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            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_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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(57, 420, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 420isize, self.parse_generated_rule_35_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(58, 422, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(60, 424, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 424isize, self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_429 = false;
                loop {
                    self.base.sync_into(atn(), 429, &mut __ctx, __loop_iter_429, &mut __sync_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 },
                        56 | 58 | 67 => 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(), 429, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_429 = true;
                            self.base.match_token_into(55, 426, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 426isize, self.parse_generated_rule_41_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_41(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 82isize, 41, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 438, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 438) {
                    __prediction
                } else {
                    let __prediction = {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        __simulator.adaptive_predict_stream_info_sll_probe(44, 0, self.base.input())
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    };
                    if __prediction.requires_full_context && self.base.prediction_mode() != antlr4_runtime::PredictionMode::Sll {
                        let __simulator = self.simulator.get_or_insert_with(|| antlr4_runtime::ParserAtnSimulator::new_shared(atn()));
                        let __prediction_context = __simulator.intern_prediction_context(self.base.rule_context_version(), self.base.prediction_context_return_states(atn()));
                        __simulator.set_exact_ambig_detection(self.base.prediction_mode() == antlr4_runtime::PredictionMode::LlExactAmbigDetection);
                        __simulator.adaptive_predict_stream_info_with_context(44, 0, self.base.input(), __prediction_context)
                            .map_err(|__error| match __error {
                                antlr4_runtime::ParserAtnSimulatorError::NoViableAlt { index, .. } => self.base.no_viable_alternative_error_at(__decision_start, index),
                                _ => self.base.no_viable_alternative_error(__decision_start),
                            })?
                    } else {
                        __prediction
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 438, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 432isize, self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(57, 434, atn(), &mut __ctx, &mut __consumed_eof)?;
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 434isize, self.parse_generated_rule_43_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(58, 436, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 437isize, self.parse_generated_rule_42_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_42(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 84isize, 42, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            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) {
                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 442, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            52 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 442, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 440isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        self.base.match_token_into(52, 443, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => 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 [none];
            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) {
                    9 | 12 => 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 },
                    _ => {
                        self.base.sync_into(atn(), 446, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            9 | 12 => 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(), 446, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 444isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        self.base.match_token_into(33, 447, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 448isize, self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_453 = false;
                loop {
                    self.base.sync_into(atn(), 453, &mut __ctx, __loop_iter_453, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        58 => 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(), 453, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_453 = true;
                            self.base.match_token_into(67, 450, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 450isize, self.parse_generated_rule_45_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 465, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    4 | 9 | 11..=12 | 57 | 61 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    56 | 58 | 67 | 72 => 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(), 465, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.sync_into(atn(), 457, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 457, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 456isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 459isize, self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        let mut __loop_iter_462 = true;
                        loop {
                            self.base.sync_into(atn(), 462, &mut __ctx, __loop_iter_462, &mut __sync_error)?;
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                4 | 9 | 11..=12 | 57 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                56 | 58 | 67 | 72 => 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(), 462, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_462 = true;
                                    antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 459isize, self.parse_generated_rule_46_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                    }
                    2 => {
                    }
                    _ => 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 [none];
            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) {
                    11 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    57 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 485, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 485) {
                            __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(55, 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(55, 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(), 485, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 467isize, self.parse_generated_rule_49_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 470, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => 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(), 470, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 468isize, self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 472isize, self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 475, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => 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(), 475, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 473isize, self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 477isize, self.parse_generated_rule_50_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    4 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 478isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.sync_into(atn(), 480, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9 | 11..=12 | 56..=58 | 61 | 67 | 70 | 72..=73 => 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(), 480, &__prediction);
                        match __prediction.alt {
                            1 => {
                                self.base.match_token_into(63, 481, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        self.base.sync_into(atn(), 483, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => 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(), 483, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 482isize, self.parse_generated_rule_47_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            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_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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(61, 488, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 488isize, self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_493 = false;
                loop {
                    self.base.sync_into(atn(), 493, &mut __ctx, __loop_iter_493, &mut __sync_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 },
                        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(), 493, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_493 = true;
                            self.base.match_token_into(55, 490, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 490isize, self.parse_generated_rule_48_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(62, 497, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 506, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 506) {
                    __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(58, 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(58, 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(), 506, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 498isize, self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 499isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(7, 504, atn(), &mut __ctx, &mut __consumed_eof)?;
                        let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            4 => 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 },
                            11 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                self.base.sync_into(atn(), 504, &mut __ctx, false, &mut __sync_error)?;
                                __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                match self.base.la(1) {
                                    4 => 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 },
                                    11 => 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(), 504, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 501isize, self.parse_generated_rule_14_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                                self.base.match_token_into(33, 505, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            3 => {
                                self.base.match_token_into(11, 505, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            _ => 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_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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 508isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_set_into(&[(7, 7), (65, 65)], 512, atn(), &mut __ctx, &mut __consumed_eof)?;
                let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 512, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            9 | 11..=12 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            57 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 512, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 510isize, self.parse_generated_rule_54_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 511isize, self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_50(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 100isize, 50, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 514isize, self.parse_generated_rule_59_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.sync_into(atn(), 516, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    63..=64 | 66 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9 | 11..=12 | 56..=58 | 67 | 70 | 72..=73 => 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(), 516, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 515isize, self.parse_generated_rule_51_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 518isize, self.parse_generated_rule_52_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
            }
            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 [none];
            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) {
                    63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    66 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 532, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            64 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            66 => 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(), 532, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(63, 522, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 522, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => 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(), 522, &__prediction);
                        match __prediction.alt {
                            1 => {
                                self.base.match_token_into(63, 523, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        self.base.match_token_into(64, 526, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 526, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => 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(), 526, &__prediction);
                        match __prediction.alt {
                            1 => {
                                self.base.match_token_into(63, 527, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    3 => {
                        self.base.match_token_into(66, 530, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 530, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            63 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 67 | 70 | 72..=73 => 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(), 530, &__prediction);
                        match __prediction.alt {
                            1 => {
                                self.base.match_token_into(63, 531, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            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_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 [none];
            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) {
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    9 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    73 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    8 => antlr4_runtime::ParserAtnPrediction { alt: 5, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    70 => antlr4_runtime::ParserAtnPrediction { alt: 6, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 540, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 540) {
                            __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(65, 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(65, 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(), 540, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 534isize, self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 535isize, self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    3 => {
                        self.base.match_token_into(9, 541, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    4 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 537isize, self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    5 => {
                        self.base.match_token_into(8, 541, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    6 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 539isize, self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => 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 [none];
            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) {
                    11..=12 => 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 },
                    73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    70 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 546, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            11..=12 => 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 },
                            73 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            70 => 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(), 546, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 542isize, self.parse_generated_rule_62_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 543isize, self.parse_generated_rule_60_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 544isize, self.parse_generated_rule_56_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    4 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 545isize, self.parse_generated_rule_55_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            success {}
            recovery {}
        }
    }

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

    #[allow(dead_code)]
    fn parse_generated_rule_55(&mut self, __precedence: i32, allow_fallback: bool) -> Result<antlr4_runtime::ParseTree, GeneratedRuleError> {
        let _ = __precedence;
        antlr4_runtime::__antlr4_rust_generated_rule! {
            ordinary self, 110isize, 55, allow_fallback, atn(), GeneratedRuleError::Fatal;
            retry [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(70, 550, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 550, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 550, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 549isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 556, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 556) {
                    __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(), 556, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(73, 553, atn(), &mut __ctx, &mut __consumed_eof)?;
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 553isize, self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        self.base.match_token_into(73, 555, atn(), &mut __ctx, &mut __consumed_eof)?;
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 555isize, self.parse_generated_rule_57_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(57, 559, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 559isize, self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_564 = false;
                loop {
                    self.base.sync_into(atn(), 564, &mut __ctx, __loop_iter_564, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        67 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        58 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    };
                    self.base.record_generated_prediction_diagnostic(atn(), 564, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_564 = true;
                            self.base.match_token_into(67, 561, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 561isize, self.parse_generated_rule_58_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(58, 568, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            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) {
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    8 => antlr4_runtime::ParserAtnPrediction { alt: 4, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 579, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 579) {
                            __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(), 579, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(12, 571, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 571, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 571, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 570isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        self.base.match_token_into(11, 575, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 575, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 575, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 574isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    3 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 577isize, self.parse_generated_rule_61_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    4 => {
                        self.base.match_token_into(8, 580, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(57, 592, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 592, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    36 | 53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9 | 11..=12 | 57..=58 | 61 | 67 | 70 | 73 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                };
                self.base.record_generated_prediction_diagnostic(atn(), 592, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.sync_into(atn(), 583, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            36 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            53 | 71 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        };
                        self.base.record_generated_prediction_diagnostic(atn(), 583, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 582isize, self.parse_generated_rule_4_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                        let mut __loop_iter_588 = false;
                        loop {
                            self.base.sync_into(atn(), 588, &mut __ctx, __loop_iter_588, &mut __sync_error)?;
                            let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                            let __prediction = match self.base.la(1) {
                                71 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                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(), 588, &__prediction);
                            match __prediction.alt {
                                1 => {
                                    __loop_iter_588 = true;
                                    antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 585isize, self.parse_generated_rule_27_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                                }
                                2 => {
                                    break;
                                }
                                _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                            }
                        }
                        self.base.match_token_into(53, 593, atn(), &mut __ctx, &mut __consumed_eof)?;
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 594isize, self.parse_generated_rule_44_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                self.base.match_token_into(58, 596, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(9, 599, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.sync_into(atn(), 599, &mut __ctx, false, &mut __sync_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 },
                    4 | 9 | 11..=12 | 56..=58 | 61 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 599, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 598isize, self.parse_generated_rule_15_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                }
                self.base.sync_into(atn(), 602, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = match self.base.la(1) {
                    61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    4 | 9 | 11..=12 | 56..=58 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 602, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 601isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                    }
                    _ => 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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(11, 605, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.match_token_into(69, 606, atn(), &mut __ctx, &mut __consumed_eof)?;
                self.base.match_token_into(11, 607, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            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) {
                    12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                    _ => {
                        self.base.sync_into(atn(), 616, &mut __ctx, false, &mut __sync_error)?;
                        __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        match self.base.la(1) {
                            12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                };
                self.base.record_generated_prediction_diagnostic(atn(), 616, &__prediction);
                match __prediction.alt {
                    1 => {
                        self.base.match_token_into(12, 610, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 610, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 610, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 609isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                            }
                            _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                        }
                    }
                    2 => {
                        self.base.match_token_into(11, 614, atn(), &mut __ctx, &mut __consumed_eof)?;
                        self.base.sync_into(atn(), 614, &mut __ctx, false, &mut __sync_error)?;
                        let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            61 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            4 | 8..=9 | 11..=12 | 56..=58 | 60 | 63..=64 | 66..=67 | 70 | 72..=73 => 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(), 614, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 613isize, self.parse_generated_rule_63_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            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_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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_token_into(61, 619, atn(), &mut __ctx, &mut __consumed_eof)?;
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 619isize, self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_624 = false;
                loop {
                    self.base.sync_into(atn(), 624, &mut __ctx, __loop_iter_624, &mut __sync_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 },
                        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(), 624, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_624 = true;
                            self.base.match_token_into(55, 621, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 621isize, self.parse_generated_rule_64_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
                self.base.match_token_into(62, 628, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.sync_into(atn(), 637, &mut __ctx, false, &mut __sync_error)?;
                let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                let __prediction = if let Some(__prediction) = self.base.ll1_decision_prediction(atn(), 637) {
                    __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(), 637, &__prediction);
                match __prediction.alt {
                    1 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 629isize, self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                    }
                    2 => {
                        antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 630isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        self.base.match_token_into(7, 635, atn(), &mut __ctx, &mut __consumed_eof)?;
                        let mut __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                        let __prediction = match self.base.la(1) {
                            9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            33 => antlr4_runtime::ParserAtnPrediction { alt: 3, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                            _ => {
                                self.base.sync_into(atn(), 635, &mut __ctx, false, &mut __sync_error)?;
                                __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                                match self.base.la(1) {
                                    9 | 12 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    11 => antlr4_runtime::ParserAtnPrediction { alt: 2, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                                    33 => 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(), 635, &__prediction);
                        match __prediction.alt {
                            1 => {
                                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 632isize, self.parse_generated_rule_66_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                            }
                            2 => {
                                self.base.match_token_into(11, 636, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            3 => {
                                self.base.match_token_into(33, 636, atn(), &mut __ctx, &mut __consumed_eof)?;
                            }
                            _ => 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_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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                self.base.match_set_into(&[(9, 9), (12, 12)], 640, atn(), &mut __ctx, &mut __consumed_eof)?;
            }
            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 [none];
            bind (__ctx, __rule_start, __consumed_eof, __sync_error);
            setup {}
            body {
                antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 641isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                let mut __loop_iter_646 = false;
                loop {
                    self.base.sync_into(atn(), 646, &mut __ctx, __loop_iter_646, &mut __sync_error)?;
                    let __decision_start = antlr4_runtime::IntStream::index(self.base.input());
                    let __prediction = match self.base.la(1) {
                        70 => antlr4_runtime::ParserAtnPrediction { alt: 1, requires_full_context: false, has_semantic_context: false, diagnostic: None },
                        36 | 48 | 53 | 55 | 62 | 71 => 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(), 646, &__prediction);
                    match __prediction.alt {
                        1 => {
                            __loop_iter_646 = true;
                            self.base.match_token_into(70, 643, atn(), &mut __ctx, &mut __consumed_eof)?;
                            antlr4_runtime::__antlr4_rust_invoke_subrule!(self, 643isize, self.parse_generated_rule_65_dispatch(0, false).map_err(GeneratedRuleError::into_error), __ctx);
                        }
                        2 => {
                            break;
                        }
                        _ => return Err(self.base.no_viable_alternative_error(__decision_start)),
                    }
                }
            }
            success {}
            recovery {}
        }
    }



    pub fn grammar_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(0)
    }
    pub fn grammar_decl(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(1)
    }
    pub fn grammar_type(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(2)
    }
    pub fn prequel_construct(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(3)
    }
    pub fn options_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(4)
    }
    pub fn option(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(5)
    }
    pub fn option_value(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(6)
    }
    pub fn delegate_grammars(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(7)
    }
    pub fn delegate_grammar(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(8)
    }
    pub fn tokens_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(9)
    }
    pub fn channels_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(10)
    }
    pub fn id_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(11)
    }
    pub fn action(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(12)
    }
    pub fn action_scope_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(13)
    }
    pub fn action_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(14)
    }
    pub fn arg_action_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(15)
    }
    pub fn mode_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(16)
    }
    pub fn rules(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(17)
    }
    pub fn rule_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(18)
    }
    pub fn parser_rule_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(19)
    }
    pub fn exception_group(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(20)
    }
    pub fn exception_handler(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(21)
    }
    pub fn finally_clause(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(22)
    }
    pub fn rule_prequel(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(23)
    }
    pub fn rule_returns(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(24)
    }
    pub fn throws_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(25)
    }
    pub fn locals_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(26)
    }
    pub fn rule_action(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(27)
    }
    pub fn rule_modifiers(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(28)
    }
    pub fn rule_modifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(29)
    }
    pub fn rule_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(30)
    }
    pub fn rule_alt_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(31)
    }
    pub fn labeled_alt(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(32)
    }
    pub fn lexer_rule_spec(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(33)
    }
    pub fn lexer_rule_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(34)
    }
    pub fn lexer_alt_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(35)
    }
    pub fn lexer_alt(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(36)
    }
    pub fn lexer_elements(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(37)
    }
    pub fn lexer_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(38)
    }
    pub fn lexer_block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(39)
    }
    pub fn lexer_commands(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(40)
    }
    pub fn lexer_command(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(41)
    }
    pub fn lexer_command_name(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(42)
    }
    pub fn lexer_command_expr(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(43)
    }
    pub fn alt_list(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(44)
    }
    pub fn alternative(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(45)
    }
    pub fn element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(46)
    }
    pub fn predicate_options(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(47)
    }
    pub fn predicate_option(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(48)
    }
    pub fn labeled_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(49)
    }
    pub fn ebnf(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(50)
    }
    pub fn block_suffix(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(51)
    }
    pub fn ebnf_suffix(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(52)
    }
    pub fn lexer_atom(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(53)
    }
    pub fn atom(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(54)
    }
    pub fn wildcard(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(55)
    }
    pub fn not_set(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(56)
    }
    pub fn block_set(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(57)
    }
    pub fn set_element(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(58)
    }
    pub fn block(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(59)
    }
    pub fn ruleref(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(60)
    }
    pub fn character_range(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(61)
    }
    pub fn terminal_def(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(62)
    }
    pub fn element_options(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(63)
    }
    pub fn element_option(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(64)
    }
    pub fn identifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(65)
    }
    pub fn qualified_identifier(&mut self) -> Result<antlr4_runtime::ParseTree, antlr4_runtime::AntlrError> {
        self.parse_rule(66)
    }


    fn run_action(&mut self, _action: antlr4_runtime::ParserAction, _tree: antlr4_runtime::ParseTree) {}

}



antlr4_runtime::__antlr4_rust_parser_facade! {
    type: AntlRv4Parser<L, H>,
    fields: {
        base: base,
        simulator: simulator,
        generated_only: generated_only,
    },
    metadata: metadata,
    parser_atn: parser_atn,
    reset(parser) {
    }
}
}

#[allow(warnings, missing_docs, clippy::all, clippy::pedantic, clippy::nursery)]
pub use self::__antlr4_rust_generated::*;
