libyang 1.1.0

// ---------------------------------------------------------
// This file was generated by parol.
// Do not edit this file manually.
// Changes will be overwritten on the next build.
// ---------------------------------------------------------

// Disable clippy warnings that can result in the way how parol generates code.
#![allow(clippy::too_many_arguments)]
#![allow(clippy::enum_variant_names)]
#![allow(clippy::large_enum_variant)]
#![allow(clippy::upper_case_acronyms)]

use parol_runtime::log::trace;
#[allow(unused_imports)]
use parol_runtime::parol_macros::{pop_and_reverse_item, pop_item};
use parol_runtime::parser::{ParseTreeType, UserActionsTrait};
use parol_runtime::{ParserError, Result, Token};

/// Semantic actions trait generated for the user grammar
/// All functions have default implementations.
pub trait YangGrammarTrait<'t> {
    /// Semantic action for non-terminal 'LBrace'
    fn l_brace(&mut self, _arg: &LBrace<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'EscN'
    fn esc_n(&mut self, _arg: &EscN<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'EscT'
    fn esc_t(&mut self, _arg: &EscT<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwModule'
    fn kw_module(&mut self, _arg: &KwModule<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwSubmodule'
    fn kw_submodule(&mut self, _arg: &KwSubmodule<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRpc'
    fn kw_rpc(&mut self, _arg: &KwRpc<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwExtension'
    fn kw_extension(&mut self, _arg: &KwExtension<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwArgument'
    fn kw_argument(&mut self, _arg: &KwArgument<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwFeature'
    fn kw_feature(&mut self, _arg: &KwFeature<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwTypedef'
    fn kw_typedef(&mut self, _arg: &KwTypedef<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwGrouping'
    fn kw_grouping(&mut self, _arg: &KwGrouping<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwIdentity'
    fn kw_identity(&mut self, _arg: &KwIdentity<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwAnyxml'
    fn kw_anyxml(&mut self, _arg: &KwAnyxml<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwAnydata'
    fn kw_anydata(&mut self, _arg: &KwAnydata<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwCase'
    fn kw_case(&mut self, _arg: &KwCase<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwContainer'
    fn kw_container(&mut self, _arg: &KwContainer<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwAction'
    fn kw_action(&mut self, _arg: &KwAction<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwNotification'
    fn kw_notification(&mut self, _arg: &KwNotification<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwLeafList'
    fn kw_leaf_list(&mut self, _arg: &KwLeafList<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwLeaf'
    fn kw_leaf(&mut self, _arg: &KwLeaf<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwList'
    fn kw_list(&mut self, _arg: &KwList<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwBit'
    fn kw_bit(&mut self, _arg: &KwBit<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwImport'
    fn kw_import(&mut self, _arg: &KwImport<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwInclude'
    fn kw_include(&mut self, _arg: &KwInclude<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwPrefix'
    fn kw_prefix(&mut self, _arg: &KwPrefix<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwBelongsTo'
    fn kw_belongs_to(&mut self, _arg: &KwBelongsTo<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwBase'
    fn kw_base(&mut self, _arg: &KwBase<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwChoice'
    fn kw_choice(&mut self, _arg: &KwChoice<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwUses'
    fn kw_uses(&mut self, _arg: &KwUses<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwType'
    fn kw_type(&mut self, _arg: &KwType<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRefine'
    fn kw_refine(&mut self, _arg: &KwRefine<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwKey'
    fn kw_key(&mut self, _arg: &KwKey<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwDeviation'
    fn kw_deviation(&mut self, _arg: &KwDeviation<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwYangVersion'
    fn kw_yang_version(&mut self, _arg: &KwYangVersion<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwStatus'
    fn kw_status(&mut self, _arg: &KwStatus<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwIfFeature'
    fn kw_if_feature(&mut self, _arg: &KwIfFeature<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwMandatory'
    fn kw_mandatory(&mut self, _arg: &KwMandatory<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwConfig'
    fn kw_config(&mut self, _arg: &KwConfig<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRequireInstance'
    fn kw_require_instance(&mut self, _arg: &KwRequireInstance<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwOrderedBy'
    fn kw_ordered_by(&mut self, _arg: &KwOrderedBy<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwDefault'
    fn kw_default(&mut self, _arg: &KwDefault<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwFractionDigits'
    fn kw_fraction_digits(&mut self, _arg: &KwFractionDigits<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwLength'
    fn kw_length(&mut self, _arg: &KwLength<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRange'
    fn kw_range(&mut self, _arg: &KwRange<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwValue'
    fn kw_value(&mut self, _arg: &KwValue<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwPosition'
    fn kw_position(&mut self, _arg: &KwPosition<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwEnum'
    fn kw_enum(&mut self, _arg: &KwEnum<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRevision'
    fn kw_revision(&mut self, _arg: &KwRevision<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwRevisionDate'
    fn kw_revision_date(&mut self, _arg: &KwRevisionDate<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KwNamespace'
    fn kw_namespace(&mut self, _arg: &KwNamespace<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Yang'
    fn yang(&mut self, _arg: &Yang<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ModuleStmt'
    fn module_stmt(&mut self, _arg: &ModuleStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SubmoduleStmt'
    fn submodule_stmt(&mut self, _arg: &SubmoduleStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ModuleHeaderStmts'
    fn module_header_stmts(&mut self, _arg: &ModuleHeaderStmts<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SubmoduleHeaderStmts'
    fn submodule_header_stmts(&mut self, _arg: &SubmoduleHeaderStmts<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MetaStmts'
    fn meta_stmts(&mut self, _arg: &MetaStmts<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LinkageStmts'
    fn linkage_stmts(&mut self, _arg: &LinkageStmts<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'BodyStmts'
    fn body_stmts(&mut self, _arg: &BodyStmts<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DataDefStmt'
    fn data_def_stmt(&mut self, _arg: &DataDefStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'YangVersionStmt'
    fn yang_version_stmt(&mut self, _arg: &YangVersionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'YangVersionArgStr'
    fn yang_version_arg_str(&mut self, _arg: &YangVersionArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DeviationStmt'
    fn deviation_stmt(&mut self, _arg: &DeviationStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RpcStmt'
    fn rpc_stmt(&mut self, _arg: &RpcStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ExtensionStmt'
    fn extension_stmt(&mut self, _arg: &ExtensionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ArgumentStmt'
    fn argument_stmt(&mut self, _arg: &ArgumentStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'FeatureStmt'
    fn feature_stmt(&mut self, _arg: &FeatureStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'TypedefStmt'
    fn typedef_stmt(&mut self, _arg: &TypedefStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AugmentStmt'
    fn augment_stmt(&mut self, _arg: &AugmentStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AugmentArgStr'
    fn augment_arg_str(&mut self, _arg: &AugmentArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'WhenStmt'
    fn when_stmt(&mut self, _arg: &WhenStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'GroupingStmt'
    fn grouping_stmt(&mut self, _arg: &GroupingStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IdentityStmt'
    fn identity_stmt(&mut self, _arg: &IdentityStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'BaseStmt'
    fn base_stmt(&mut self, _arg: &BaseStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AnyxmlStmt'
    fn anyxml_stmt(&mut self, _arg: &AnyxmlStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ChoiceStmt'
    fn choice_stmt(&mut self, _arg: &ChoiceStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ShortCaseStmt'
    fn short_case_stmt(&mut self, _arg: &ShortCaseStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AnydataStmt'
    fn anydata_stmt(&mut self, _arg: &AnydataStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'CaseStmt'
    fn case_stmt(&mut self, _arg: &CaseStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'StatusStmt'
    fn status_stmt(&mut self, _arg: &StatusStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'StatusArgStr'
    fn status_arg_str(&mut self, _arg: &StatusArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'StatusArg'
    fn status_arg(&mut self, _arg: &StatusArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ContainerStmt'
    fn container_stmt(&mut self, _arg: &ContainerStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ActionStmt'
    fn action_stmt(&mut self, _arg: &ActionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'InputStmt'
    fn input_stmt(&mut self, _arg: &InputStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'OutputStmt'
    fn output_stmt(&mut self, _arg: &OutputStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'NotificationStmt'
    fn notification_stmt(&mut self, _arg: &NotificationStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IfFeatureStmt'
    fn if_feature_stmt(&mut self, _arg: &IfFeatureStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IfFeatureExprStr'
    fn if_feature_expr_str(&mut self, _arg: &IfFeatureExprStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IfFeatureExpr'
    fn if_feature_expr(&mut self, _arg: &IfFeatureExpr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IfFeatureTerm'
    fn if_feature_term(&mut self, _arg: &IfFeatureTerm<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IfFeatureFactor'
    fn if_feature_factor(&mut self, _arg: &IfFeatureFactor<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PresenceStmt'
    fn presence_stmt(&mut self, _arg: &PresenceStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UsesStmt'
    fn uses_stmt(&mut self, _arg: &UsesStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RefineStmt'
    fn refine_stmt(&mut self, _arg: &RefineStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RefineArgStr'
    fn refine_arg_str(&mut self, _arg: &RefineArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RefineArg'
    fn refine_arg(&mut self, _arg: &RefineArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DescendantSchemaNodeid'
    fn descendant_schema_nodeid(&mut self, _arg: &DescendantSchemaNodeid<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UnknownStmt'
    fn unknown_stmt(&mut self, _arg: &UnknownStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LeafListStmt'
    fn leaf_list_stmt(&mut self, _arg: &LeafListStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LeafStmt'
    fn leaf_stmt(&mut self, _arg: &LeafStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MustStmt'
    fn must_stmt(&mut self, _arg: &MustStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ErrorMessage'
    fn error_message(&mut self, _arg: &ErrorMessage<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UnitsStmt'
    fn units_stmt(&mut self, _arg: &UnitsStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ConfigStmt'
    fn config_stmt(&mut self, _arg: &ConfigStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MandatoryStmt'
    fn mandatory_stmt(&mut self, _arg: &MandatoryStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MandatoryArgStr'
    fn mandatory_arg_str(&mut self, _arg: &MandatoryArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MandatoryArg'
    fn mandatory_arg(&mut self, _arg: &MandatoryArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ListStmt'
    fn list_stmt(&mut self, _arg: &ListStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'OrderedByStmt'
    fn ordered_by_stmt(&mut self, _arg: &OrderedByStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'OrderedByArgStr'
    fn ordered_by_arg_str(&mut self, _arg: &OrderedByArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'OrderedByArg'
    fn ordered_by_arg(&mut self, _arg: &OrderedByArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DefaultStmt'
    fn default_stmt(&mut self, _arg: &DefaultStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MaxElementsStmt'
    fn max_elements_stmt(&mut self, _arg: &MaxElementsStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MinElementsStmt'
    fn min_elements_stmt(&mut self, _arg: &MinElementsStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'TypeStmt'
    fn type_stmt(&mut self, _arg: &TypeStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'FractionDigitsStmt'
    fn fraction_digits_stmt(&mut self, _arg: &FractionDigitsStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'FractionDigitsArg'
    fn fraction_digits_arg(&mut self, _arg: &FractionDigitsArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'BitStmt'
    fn bit_stmt(&mut self, _arg: &BitStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PositionStmt'
    fn position_stmt(&mut self, _arg: &PositionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LeafrefSpecification'
    fn leafref_specification(&mut self, _arg: &LeafrefSpecification<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RequireInstanceStmt'
    fn require_instance_stmt(&mut self, _arg: &RequireInstanceStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RequireInstanceArgStr'
    fn require_instance_arg_str(&mut self, _arg: &RequireInstanceArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PathStmt'
    fn path_stmt(&mut self, _arg: &PathStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'StringRestrictions'
    fn string_restrictions(&mut self, _arg: &StringRestrictions<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PatternStmt'
    fn pattern_stmt(&mut self, _arg: &PatternStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LengthStmt'
    fn length_stmt(&mut self, _arg: &LengthStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'EnumStmt'
    fn enum_stmt(&mut self, _arg: &EnumStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ValueStmt'
    fn value_stmt(&mut self, _arg: &ValueStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IntegerValueStr'
    fn integer_value_str(&mut self, _arg: &IntegerValueStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IntegerValue'
    fn integer_value(&mut self, _arg: &IntegerValue<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'EnumArgStr'
    fn enum_arg_str(&mut self, _arg: &EnumArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RangeStmt'
    fn range_stmt(&mut self, _arg: &RangeStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RangeArgStr'
    fn range_arg_str(&mut self, _arg: &RangeArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RangeArg'
    fn range_arg(&mut self, _arg: &RangeArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RangePart'
    fn range_part(&mut self, _arg: &RangePart<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RangeBoundary'
    fn range_boundary(&mut self, _arg: &RangeBoundary<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IdentifierRefArgStr'
    fn identifier_ref_arg_str(&mut self, _arg: &IdentifierRefArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IdentifierRef'
    fn identifier_ref(&mut self, _arg: &IdentifierRef<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KeyStmt'
    fn key_stmt(&mut self, _arg: &KeyStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KeyArgStr'
    fn key_arg_str(&mut self, _arg: &KeyArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Semicolon'
    fn semicolon(&mut self, _arg: &Semicolon<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'KeyArg'
    fn key_arg(&mut self, _arg: &KeyArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AbsoluteSchemaNodeid'
    fn absolute_schema_nodeid(&mut self, _arg: &AbsoluteSchemaNodeid<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ImportStmt'
    fn import_stmt(&mut self, _arg: &ImportStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IncludeStmt'
    fn include_stmt(&mut self, _arg: &IncludeStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RevisionDateStmt'
    fn revision_date_stmt(&mut self, _arg: &RevisionDateStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'NamespaceStmt'
    fn namespace_stmt(&mut self, _arg: &NamespaceStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UriStr'
    fn uri_str(&mut self, _arg: &UriStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UriArg'
    fn uri_arg(&mut self, _arg: &UriArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PrefixStmt'
    fn prefix_stmt(&mut self, _arg: &PrefixStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'BelongsToStmt'
    fn belongs_to_stmt(&mut self, _arg: &BelongsToStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'OrganizationStmt'
    fn organization_stmt(&mut self, _arg: &OrganizationStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ContactStmt'
    fn contact_stmt(&mut self, _arg: &ContactStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DescriptionStmt'
    fn description_stmt(&mut self, _arg: &DescriptionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ReferenceStmt'
    fn reference_stmt(&mut self, _arg: &ReferenceStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RevisionStmt'
    fn revision_stmt(&mut self, _arg: &RevisionStmt<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DateArgStr'
    fn date_arg_str(&mut self, _arg: &DateArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DateArg'
    fn date_arg(&mut self, _arg: &DateArg<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Ystring'
    fn ystring(&mut self, _arg: &Ystring<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'BasicString'
    fn basic_string(&mut self, _arg: &BasicString<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DoubleQuotation'
    fn double_quotation(&mut self, _arg: &DoubleQuotation<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQString'
    fn d_q_string(&mut self, _arg: &DQString<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQChar'
    fn d_q_char(&mut self, _arg: &DQChar<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQUnescaped'
    fn d_q_unescaped(&mut self, _arg: &DQUnescaped<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQEscaped'
    fn d_q_escaped(&mut self, _arg: &DQEscaped<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQEscapeSeqChar'
    fn d_q_escape_seq_char(&mut self, _arg: &DQEscapeSeqChar<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Escape'
    fn escape(&mut self, _arg: &Escape<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'NonAscii'
    fn non_ascii(&mut self, _arg: &NonAscii<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DQNoEscape'
    fn d_q_no_escape(&mut self, _arg: &DQNoEscape<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQString'
    fn s_q_string(&mut self, _arg: &SQString<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQChar'
    fn s_q_char(&mut self, _arg: &SQChar<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQEscaped'
    fn s_q_escaped(&mut self, _arg: &SQEscaped<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQEscapeSeqChar'
    fn s_q_escape_seq_char(&mut self, _arg: &SQEscapeSeqChar<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQUnescaped'
    fn s_q_unescaped(&mut self, _arg: &SQUnescaped<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SQNoEscape'
    fn s_q_no_escape(&mut self, _arg: &SQNoEscape<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SingleQuotation'
    fn single_quotation(&mut self, _arg: &SingleQuotation<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IdentifierArgStr'
    fn identifier_arg_str(&mut self, _arg: &IdentifierArgStr<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Identifier'
    fn identifier(&mut self, _arg: &Identifier<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AsciiNoSemicolon'
    fn ascii_no_semicolon(&mut self, _arg: &AsciiNoSemicolon<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'AsciiNoBrace'
    fn ascii_no_brace(&mut self, _arg: &AsciiNoBrace<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'YangVersionArg'
    fn yang_version_arg(&mut self, _arg: &YangVersionArg<'t>) -> Result<()> {
        Ok(())
    }

    /// This method provides skipped language comments.
    /// If you need comments please provide your own implementation of this method.
    fn on_comment(&mut self, _token: Token<'t>) {}
}

// -------------------------------------------------------------------------------------------------
//
// Output Types of productions deduced from the structure of the transformed grammar
//

///
/// Type derived for production 50
///
/// `Yang: ModuleStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangModuleStmt<'t> {
    pub module_stmt: Box<ModuleStmt<'t>>,
}

///
/// Type derived for production 51
///
/// `Yang: SubmoduleStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangSubmoduleStmt<'t> {
    pub submodule_stmt: Box<SubmoduleStmt<'t>>,
}

///
/// Type derived for production 74
///
/// `ModuleHeaderStmts: YangVersionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleHeaderStmtsYangVersionStmt<'t> {
    pub yang_version_stmt: Box<YangVersionStmt<'t>>,
}

///
/// Type derived for production 75
///
/// `ModuleHeaderStmts: NamespaceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleHeaderStmtsNamespaceStmt<'t> {
    pub namespace_stmt: Box<NamespaceStmt<'t>>,
}

///
/// Type derived for production 76
///
/// `ModuleHeaderStmts: PrefixStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleHeaderStmtsPrefixStmt<'t> {
    pub prefix_stmt: Box<PrefixStmt<'t>>,
}

///
/// Type derived for production 77
///
/// `SubmoduleHeaderStmts: YangVersionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleHeaderStmtsYangVersionStmt<'t> {
    pub yang_version_stmt: Box<YangVersionStmt<'t>>,
}

///
/// Type derived for production 78
///
/// `SubmoduleHeaderStmts: BelongsToStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleHeaderStmtsBelongsToStmt<'t> {
    pub belongs_to_stmt: Box<BelongsToStmt<'t>>,
}

///
/// Type derived for production 79
///
/// `MetaStmts: OrganizationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MetaStmtsOrganizationStmt<'t> {
    pub organization_stmt: Box<OrganizationStmt<'t>>,
}

///
/// Type derived for production 80
///
/// `MetaStmts: ContactStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MetaStmtsContactStmt<'t> {
    pub contact_stmt: Box<ContactStmt<'t>>,
}

///
/// Type derived for production 81
///
/// `MetaStmts: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MetaStmtsDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 82
///
/// `MetaStmts: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MetaStmtsReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 83
///
/// `LinkageStmts: ImportStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LinkageStmtsImportStmt<'t> {
    pub import_stmt: Box<ImportStmt<'t>>,
}

///
/// Type derived for production 84
///
/// `LinkageStmts: IncludeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LinkageStmtsIncludeStmt<'t> {
    pub include_stmt: Box<IncludeStmt<'t>>,
}

///
/// Type derived for production 85
///
/// `BodyStmts: ExtensionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsExtensionStmt<'t> {
    pub extension_stmt: Box<ExtensionStmt<'t>>,
}

///
/// Type derived for production 86
///
/// `BodyStmts: FeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsFeatureStmt<'t> {
    pub feature_stmt: Box<FeatureStmt<'t>>,
}

///
/// Type derived for production 87
///
/// `BodyStmts: IdentityStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsIdentityStmt<'t> {
    pub identity_stmt: Box<IdentityStmt<'t>>,
}

///
/// Type derived for production 88
///
/// `BodyStmts: TypedefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsTypedefStmt<'t> {
    pub typedef_stmt: Box<TypedefStmt<'t>>,
}

///
/// Type derived for production 89
///
/// `BodyStmts: GroupingStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsGroupingStmt<'t> {
    pub grouping_stmt: Box<GroupingStmt<'t>>,
}

///
/// Type derived for production 90
///
/// `BodyStmts: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 91
///
/// `BodyStmts: AugmentStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsAugmentStmt<'t> {
    pub augment_stmt: Box<AugmentStmt<'t>>,
}

///
/// Type derived for production 92
///
/// `BodyStmts: RpcStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsRpcStmt<'t> {
    pub rpc_stmt: Box<RpcStmt<'t>>,
}

///
/// Type derived for production 93
///
/// `BodyStmts: NotificationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsNotificationStmt<'t> {
    pub notification_stmt: Box<NotificationStmt<'t>>,
}

///
/// Type derived for production 94
///
/// `BodyStmts: DeviationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsDeviationStmt<'t> {
    pub deviation_stmt: Box<DeviationStmt<'t>>,
}

///
/// Type derived for production 95
///
/// `BodyStmts: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BodyStmtsUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 96
///
/// `DataDefStmt: ContainerStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtContainerStmt<'t> {
    pub container_stmt: Box<ContainerStmt<'t>>,
}

///
/// Type derived for production 97
///
/// `DataDefStmt: LeafStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtLeafStmt<'t> {
    pub leaf_stmt: Box<LeafStmt<'t>>,
}

///
/// Type derived for production 98
///
/// `DataDefStmt: LeafListStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtLeafListStmt<'t> {
    pub leaf_list_stmt: Box<LeafListStmt<'t>>,
}

///
/// Type derived for production 99
///
/// `DataDefStmt: ListStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtListStmt<'t> {
    pub list_stmt: Box<ListStmt<'t>>,
}

///
/// Type derived for production 100
///
/// `DataDefStmt: ChoiceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtChoiceStmt<'t> {
    pub choice_stmt: Box<ChoiceStmt<'t>>,
}

///
/// Type derived for production 101
///
/// `DataDefStmt: AnydataStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtAnydataStmt<'t> {
    pub anydata_stmt: Box<AnydataStmt<'t>>,
}

///
/// Type derived for production 102
///
/// `DataDefStmt: AnyxmlStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtAnyxmlStmt<'t> {
    pub anyxml_stmt: Box<AnyxmlStmt<'t>>,
}

///
/// Type derived for production 103
///
/// `DataDefStmt: UsesStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DataDefStmtUsesStmt<'t> {
    pub uses_stmt: Box<UsesStmt<'t>>,
}

///
/// Type derived for production 105
///
/// `YangVersionArgStr: YangVersionArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangVersionArgStrYangVersionArg<'t> {
    pub yang_version_arg: Box<YangVersionArg<'t>>,
}

///
/// Type derived for production 106
///
/// `YangVersionArgStr: <YVersion>'"'^ /* Clipped */ YangVersionArg <YVersion>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangVersionArgStrDoubleQuotationYangVersionArgDoubleQuotation<'t> {
    pub yang_version_arg: Box<YangVersionArg<'t>>,
}

///
/// Type derived for production 109
///
/// `RpcStmtSuffix: Semicolon;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtSuffixSemicolon<'t> {
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for production 110
///
/// `RpcStmtSuffix: LBrace^ /* Clipped */ RpcStmtList /* Vec */ '}';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtSuffixLBraceRpcStmtListRBrace<'t> {
    pub rpc_stmt_list: Vec<RpcStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for production 112
///
/// `RpcStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 113
///
/// `RpcStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 114
///
/// `RpcStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 115
///
/// `RpcStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 116
///
/// `RpcStmtListGroup: TypedefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupTypedefStmt<'t> {
    pub typedef_stmt: Box<TypedefStmt<'t>>,
}

///
/// Type derived for production 117
///
/// `RpcStmtListGroup: GroupingStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupGroupingStmt<'t> {
    pub grouping_stmt: Box<GroupingStmt<'t>>,
}

///
/// Type derived for production 118
///
/// `RpcStmtListGroup: InputStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupInputStmt<'t> {
    pub input_stmt: Box<InputStmt<'t>>,
}

///
/// Type derived for production 119
///
/// `RpcStmtListGroup: OutputStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtListGroupOutputStmt<'t> {
    pub output_stmt: Box<OutputStmt<'t>>,
}

///
/// Type derived for production 122
///
/// `ExtensionStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtSuffixSemicolon {}

///
/// Type derived for production 123
///
/// `ExtensionStmtSuffix: LBrace^ /* Clipped */ ExtensionStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtSuffixLBraceExtensionStmtListRBrace<'t> {
    pub extension_stmt_list: Vec<ExtensionStmtList<'t>>,
}

///
/// Type derived for production 125
///
/// `ExtensionStmtListGroup: ArgumentStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtListGroupArgumentStmt<'t> {
    pub argument_stmt: Box<ArgumentStmt<'t>>,
}

///
/// Type derived for production 126
///
/// `ExtensionStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 127
///
/// `ExtensionStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 128
///
/// `ExtensionStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 132
///
/// `FeatureStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtSuffixSemicolon {}

///
/// Type derived for production 133
///
/// `FeatureStmtSuffix: LBrace^ /* Clipped */ FeatureStmtList /* Vec */ '}';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtSuffixLBraceFeatureStmtListRBrace<'t> {
    pub feature_stmt_list: Vec<FeatureStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for production 135
///
/// `FeatureStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 136
///
/// `FeatureStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 137
///
/// `FeatureStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 138
///
/// `FeatureStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 142
///
/// `TypedefStmtListGroup: TypeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupTypeStmt<'t> {
    pub type_stmt: Box<TypeStmt<'t>>,
}

///
/// Type derived for production 143
///
/// `TypedefStmtListGroup: UnitsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupUnitsStmt<'t> {
    pub units_stmt: Box<UnitsStmt<'t>>,
}

///
/// Type derived for production 144
///
/// `TypedefStmtListGroup: DefaultStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupDefaultStmt<'t> {
    pub default_stmt: Box<DefaultStmt<'t>>,
}

///
/// Type derived for production 145
///
/// `TypedefStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 146
///
/// `TypedefStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 147
///
/// `TypedefStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 151
///
/// `AugmentStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 152
///
/// `AugmentStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 153
///
/// `AugmentStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 154
///
/// `AugmentStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 155
///
/// `AugmentStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 156
///
/// `AugmentStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 157
///
/// `AugmentStmtListGroup: CaseStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupCaseStmt<'t> {
    pub case_stmt: Box<CaseStmt<'t>>,
}

///
/// Type derived for production 158
///
/// `AugmentStmtListGroup: ActionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupActionStmt<'t> {
    pub action_stmt: Box<ActionStmt<'t>>,
}

///
/// Type derived for production 159
///
/// `AugmentStmtListGroup: NotificationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtListGroupNotificationStmt<'t> {
    pub notification_stmt: Box<NotificationStmt<'t>>,
}

///
/// Type derived for production 163
///
/// `WhenStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmtSuffixSemicolon {}

///
/// Type derived for production 164
///
/// `WhenStmtSuffix: LBrace^ /* Clipped */ WhenStmtList /* Vec */ '}';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmtSuffixLBraceWhenStmtListRBrace<'t> {
    pub when_stmt_list: Vec<WhenStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for production 166
///
/// `WhenStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 167
///
/// `WhenStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 171
///
/// `GroupingStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 172
///
/// `GroupingStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 173
///
/// `GroupingStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 174
///
/// `GroupingStmtListGroup: TypedefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupTypedefStmt<'t> {
    pub typedef_stmt: Box<TypedefStmt<'t>>,
}

///
/// Type derived for production 175
///
/// `GroupingStmtListGroup: GroupingStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupGroupingStmt<'t> {
    pub grouping_stmt: Box<GroupingStmt<'t>>,
}

///
/// Type derived for production 176
///
/// `GroupingStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 177
///
/// `GroupingStmtListGroup: ActionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupActionStmt<'t> {
    pub action_stmt: Box<ActionStmt<'t>>,
}

///
/// Type derived for production 178
///
/// `GroupingStmtListGroup: NotificationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupNotificationStmt<'t> {
    pub notification_stmt: Box<NotificationStmt<'t>>,
}

///
/// Type derived for production 179
///
/// `GroupingStmtListGroup: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtListGroupUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 183
///
/// `IdentityStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 184
///
/// `IdentityStmtListGroup: BaseStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmtListGroupBaseStmt<'t> {
    pub base_stmt: Box<BaseStmt<'t>>,
}

///
/// Type derived for production 185
///
/// `IdentityStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 186
///
/// `IdentityStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 190
///
/// `AnyxmlStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtSuffixSemicolon {}

///
/// Type derived for production 191
///
/// `AnyxmlStmtSuffix: LBrace^ /* Clipped */ AnyxmlStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtSuffixLBraceAnyxmlStmtListRBrace<'t> {
    pub anyxml_stmt_list: Vec<AnyxmlStmtList<'t>>,
}

///
/// Type derived for production 193
///
/// `AnyxmlStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 194
///
/// `AnyxmlStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 195
///
/// `AnyxmlStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 196
///
/// `AnyxmlStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 197
///
/// `AnyxmlStmtListGroup: MandatoryStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupMandatoryStmt<'t> {
    pub mandatory_stmt: Box<MandatoryStmt<'t>>,
}

///
/// Type derived for production 198
///
/// `AnyxmlStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 199
///
/// `AnyxmlStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 200
///
/// `AnyxmlStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 203
///
/// `ChoiceStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtSuffixSemicolon {}

///
/// Type derived for production 204
///
/// `ChoiceStmtSuffix: LBrace^ /* Clipped */ ChoiceStmtList /* Vec */ '}';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtSuffixLBraceChoiceStmtListRBrace<'t> {
    pub choice_stmt_list: Vec<ChoiceStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for production 206
///
/// `ChoiceStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 207
///
/// `ChoiceStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 208
///
/// `ChoiceStmtListGroup: DefaultStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupDefaultStmt<'t> {
    pub default_stmt: Box<DefaultStmt<'t>>,
}

///
/// Type derived for production 209
///
/// `ChoiceStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 210
///
/// `ChoiceStmtListGroup: MandatoryStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupMandatoryStmt<'t> {
    pub mandatory_stmt: Box<MandatoryStmt<'t>>,
}

///
/// Type derived for production 211
///
/// `ChoiceStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 212
///
/// `ChoiceStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 213
///
/// `ChoiceStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 214
///
/// `ChoiceStmtListGroup: ShortCaseStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupShortCaseStmt<'t> {
    pub short_case_stmt: Box<ShortCaseStmt<'t>>,
}

///
/// Type derived for production 215
///
/// `ChoiceStmtListGroup: CaseStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtListGroupCaseStmt<'t> {
    pub case_stmt: Box<CaseStmt<'t>>,
}

///
/// Type derived for production 217
///
/// `ShortCaseStmt: ChoiceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtChoiceStmt<'t> {
    pub choice_stmt: Box<ChoiceStmt<'t>>,
}

///
/// Type derived for production 218
///
/// `ShortCaseStmt: ContainerStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtContainerStmt<'t> {
    pub container_stmt: Box<ContainerStmt<'t>>,
}

///
/// Type derived for production 219
///
/// `ShortCaseStmt: LeafStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtLeafStmt<'t> {
    pub leaf_stmt: Box<LeafStmt<'t>>,
}

///
/// Type derived for production 220
///
/// `ShortCaseStmt: LeafListStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtLeafListStmt<'t> {
    pub leaf_list_stmt: Box<LeafListStmt<'t>>,
}

///
/// Type derived for production 221
///
/// `ShortCaseStmt: ListStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtListStmt<'t> {
    pub list_stmt: Box<ListStmt<'t>>,
}

///
/// Type derived for production 222
///
/// `ShortCaseStmt: AnydataStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtAnydataStmt<'t> {
    pub anydata_stmt: Box<AnydataStmt<'t>>,
}

///
/// Type derived for production 223
///
/// `ShortCaseStmt: AnyxmlStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ShortCaseStmtAnyxmlStmt<'t> {
    pub anyxml_stmt: Box<AnyxmlStmt<'t>>,
}

///
/// Type derived for production 225
///
/// `AnydataStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtSuffixSemicolon {}

///
/// Type derived for production 226
///
/// `AnydataStmtSuffix: LBrace^ /* Clipped */ AnydataStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtSuffixLBraceAnydataStmtListRBrace<'t> {
    pub anydata_stmt_list: Vec<AnydataStmtList<'t>>,
}

///
/// Type derived for production 228
///
/// `AnydataStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 229
///
/// `AnydataStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 230
///
/// `AnydataStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 231
///
/// `AnydataStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 232
///
/// `AnydataStmtListGroup: MandatoryStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupMandatoryStmt<'t> {
    pub mandatory_stmt: Box<MandatoryStmt<'t>>,
}

///
/// Type derived for production 233
///
/// `AnydataStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 234
///
/// `AnydataStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 235
///
/// `AnydataStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 238
///
/// `CaseStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtSuffixSemicolon {}

///
/// Type derived for production 239
///
/// `CaseStmtSuffix: LBrace^ /* Clipped */ CaseStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtSuffixLBraceCaseStmtListRBrace<'t> {
    pub case_stmt_list: Vec<CaseStmtList<'t>>,
}

///
/// Type derived for production 241
///
/// `CaseStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 242
///
/// `CaseStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 243
///
/// `CaseStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 244
///
/// `CaseStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 245
///
/// `CaseStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 248
///
/// `StatusArgStr: StatusArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StatusArgStrStatusArg<'t> {
    pub status_arg: Box<StatusArg<'t>>,
}

///
/// Type derived for production 249
///
/// `StatusArgStr: <Status>'"'^ /* Clipped */ StatusArg <Status>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StatusArgStrDoubleQuotationStatusArgDoubleQuotation<'t> {
    pub status_arg: Box<StatusArg<'t>>,
}

///
/// Type derived for production 252
///
/// `ContainerStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtSuffixSemicolon {}

///
/// Type derived for production 253
///
/// `ContainerStmtSuffix: LBrace^ /* Clipped */ ContainerStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtSuffixLBraceContainerStmtListRBrace<'t> {
    pub container_stmt_list: Vec<ContainerStmtList<'t>>,
}

///
/// Type derived for production 255
///
/// `ContainerStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 256
///
/// `ContainerStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 257
///
/// `ContainerStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 258
///
/// `ContainerStmtListGroup: PresenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupPresenceStmt<'t> {
    pub presence_stmt: Box<PresenceStmt<'t>>,
}

///
/// Type derived for production 259
///
/// `ContainerStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 260
///
/// `ContainerStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 261
///
/// `ContainerStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 262
///
/// `ContainerStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 263
///
/// `ContainerStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 264
///
/// `ContainerStmtListGroup: ActionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupActionStmt<'t> {
    pub action_stmt: Box<ActionStmt<'t>>,
}

///
/// Type derived for production 265
///
/// `ContainerStmtListGroup: NotificationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupNotificationStmt<'t> {
    pub notification_stmt: Box<NotificationStmt<'t>>,
}

///
/// Type derived for production 266
///
/// `ContainerStmtListGroup: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtListGroupUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 269
///
/// `ActionStmtSuffix: Semicolon;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtSuffixSemicolon<'t> {
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for production 270
///
/// `ActionStmtSuffix: LBrace^ /* Clipped */ ActionStmtList /* Vec */ '}';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtSuffixLBraceActionStmtListRBrace<'t> {
    pub action_stmt_list: Vec<ActionStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for production 272
///
/// `ActionStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 273
///
/// `ActionStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 274
///
/// `ActionStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 275
///
/// `ActionStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 276
///
/// `ActionStmtListGroup: InputStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupInputStmt<'t> {
    pub input_stmt: Box<InputStmt<'t>>,
}

///
/// Type derived for production 277
///
/// `ActionStmtListGroup: OutputStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtListGroupOutputStmt<'t> {
    pub output_stmt: Box<OutputStmt<'t>>,
}

///
/// Type derived for production 287
///
/// `NotificationStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 288
///
/// `NotificationStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 289
///
/// `NotificationStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 290
///
/// `NotificationStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 291
///
/// `NotificationStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 292
///
/// `NotificationStmtListGroup: TypedefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupTypedefStmt<'t> {
    pub typedef_stmt: Box<TypedefStmt<'t>>,
}

///
/// Type derived for production 293
///
/// `NotificationStmtListGroup: GroupingStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupGroupingStmt<'t> {
    pub grouping_stmt: Box<GroupingStmt<'t>>,
}

///
/// Type derived for production 294
///
/// `NotificationStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 304
///
/// `IfFeatureFactor: <IfFeature>'not' IfFeatureFactor;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureFactorNotIfFeatureFactor<'t> {
    pub not: Token<'t>, /* not */
    pub if_feature_factor: Box<IfFeatureFactor<'t>>,
}

///
/// Type derived for production 305
///
/// `IfFeatureFactor: <IfFeature>'(' IfFeatureExpr <IfFeature>')';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureFactorLParenIfFeatureExprRParen<'t> {
    pub l_paren: Token<'t>, /* ( */
    pub if_feature_expr: Box<IfFeatureExpr<'t>>,
    pub r_paren: Token<'t>, /* ) */
}

///
/// Type derived for production 306
///
/// `IfFeatureFactor: Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureFactorIdentifier<'t> {
    pub identifier: Box<Identifier<'t>>,
}

///
/// Type derived for production 307
///
/// `IfFeatureFactor: <IfFeature>'"' Identifier <IfFeature>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureFactorDoubleQuotationIdentifierDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub identifier: Box<Identifier<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 310
///
/// `UsesStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtSuffixSemicolon {}

///
/// Type derived for production 311
///
/// `UsesStmtSuffix: LBrace^ /* Clipped */ UsesStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtSuffixLBraceUsesStmtListRBrace<'t> {
    pub uses_stmt_list: Vec<UsesStmtList<'t>>,
}

///
/// Type derived for production 313
///
/// `UsesStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 314
///
/// `UsesStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 315
///
/// `UsesStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 316
///
/// `UsesStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 317
///
/// `UsesStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 318
///
/// `UsesStmtListGroup: RefineStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupRefineStmt<'t> {
    pub refine_stmt: Box<RefineStmt<'t>>,
}

///
/// Type derived for production 319
///
/// `UsesStmtListGroup: AugmentStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtListGroupAugmentStmt<'t> {
    pub augment_stmt: Box<AugmentStmt<'t>>,
}

///
/// Type derived for production 322
///
/// `RefineStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtSuffixSemicolon {}

///
/// Type derived for production 323
///
/// `RefineStmtSuffix: LBrace^ /* Clipped */ RefineStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtSuffixLBraceRefineStmtListRBrace<'t> {
    pub refine_stmt_list: Vec<RefineStmtList<'t>>,
}

///
/// Type derived for production 325
///
/// `RefineStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 326
///
/// `RefineStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 327
///
/// `RefineStmtListGroup: PresenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupPresenceStmt<'t> {
    pub presence_stmt: Box<PresenceStmt<'t>>,
}

///
/// Type derived for production 328
///
/// `RefineStmtListGroup: DefaultStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupDefaultStmt<'t> {
    pub default_stmt: Box<DefaultStmt<'t>>,
}

///
/// Type derived for production 329
///
/// `RefineStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 330
///
/// `RefineStmtListGroup: MandatoryStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupMandatoryStmt<'t> {
    pub mandatory_stmt: Box<MandatoryStmt<'t>>,
}

///
/// Type derived for production 331
///
/// `RefineStmtListGroup: MinElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupMinElementsStmt<'t> {
    pub min_elements_stmt: Box<MinElementsStmt<'t>>,
}

///
/// Type derived for production 332
///
/// `RefineStmtListGroup: MaxElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupMaxElementsStmt<'t> {
    pub max_elements_stmt: Box<MaxElementsStmt<'t>>,
}

///
/// Type derived for production 333
///
/// `RefineStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 334
///
/// `RefineStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 336
///
/// `RefineArgStr: RefineArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineArgStrRefineArg<'t> {
    pub refine_arg: Box<RefineArg<'t>>,
}

///
/// Type derived for production 337
///
/// `RefineArgStr: <Keyword>'"' RefineArg <Keyword>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineArgStrDoubleQuotationRefineArgDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub refine_arg: Box<RefineArg<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 339
///
/// `DescendantSchemaNodeid: IdentifierRef;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DescendantSchemaNodeidIdentifierRef<'t> {
    pub identifier_ref: Box<IdentifierRef<'t>>,
}

///
/// Type derived for production 340
///
/// `DescendantSchemaNodeid: AbsoluteSchemaNodeid;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DescendantSchemaNodeidAbsoluteSchemaNodeid<'t> {
    pub absolute_schema_nodeid: Box<AbsoluteSchemaNodeid<'t>>,
}

///
/// Type derived for production 342
///
/// `UnknownStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmtSuffixSemicolon {}

///
/// Type derived for production 343
///
/// `UnknownStmtSuffix: LBrace^ /* Clipped */ UnknownStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmtSuffixLBraceUnknownStmtListRBrace<'t> {
    pub unknown_stmt_list: Vec<UnknownStmtList<'t>>,
}

///
/// Type derived for production 345
///
/// `UnknownStmtListGroup: TypeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmtListGroupTypeStmt<'t> {
    pub type_stmt: Box<TypeStmt<'t>>,
}

///
/// Type derived for production 346
///
/// `UnknownStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 350
///
/// `LeafListStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 351
///
/// `LeafListStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 352
///
/// `LeafListStmtListGroup: TypeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupTypeStmt<'t> {
    pub type_stmt: Box<TypeStmt<'t>>,
}

///
/// Type derived for production 353
///
/// `LeafListStmtListGroup: UnitsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupUnitsStmt<'t> {
    pub units_stmt: Box<UnitsStmt<'t>>,
}

///
/// Type derived for production 354
///
/// `LeafListStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 355
///
/// `LeafListStmtListGroup: DefaultStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupDefaultStmt<'t> {
    pub default_stmt: Box<DefaultStmt<'t>>,
}

///
/// Type derived for production 356
///
/// `LeafListStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 357
///
/// `LeafListStmtListGroup: MinElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupMinElementsStmt<'t> {
    pub min_elements_stmt: Box<MinElementsStmt<'t>>,
}

///
/// Type derived for production 358
///
/// `LeafListStmtListGroup: MaxElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupMaxElementsStmt<'t> {
    pub max_elements_stmt: Box<MaxElementsStmt<'t>>,
}

///
/// Type derived for production 359
///
/// `LeafListStmtListGroup: OrderedByStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupOrderedByStmt<'t> {
    pub ordered_by_stmt: Box<OrderedByStmt<'t>>,
}

///
/// Type derived for production 360
///
/// `LeafListStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 361
///
/// `LeafListStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 362
///
/// `LeafListStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 363
///
/// `LeafListStmtListGroup: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtListGroupUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 367
///
/// `LeafStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 368
///
/// `LeafStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 369
///
/// `LeafStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 370
///
/// `LeafStmtListGroup: TypeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupTypeStmt<'t> {
    pub type_stmt: Box<TypeStmt<'t>>,
}

///
/// Type derived for production 371
///
/// `LeafStmtListGroup: UnitsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupUnitsStmt<'t> {
    pub units_stmt: Box<UnitsStmt<'t>>,
}

///
/// Type derived for production 372
///
/// `LeafStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 373
///
/// `LeafStmtListGroup: DefaultStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupDefaultStmt<'t> {
    pub default_stmt: Box<DefaultStmt<'t>>,
}

///
/// Type derived for production 374
///
/// `LeafStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 375
///
/// `LeafStmtListGroup: MandatoryStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupMandatoryStmt<'t> {
    pub mandatory_stmt: Box<MandatoryStmt<'t>>,
}

///
/// Type derived for production 376
///
/// `LeafStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 377
///
/// `LeafStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 378
///
/// `LeafStmtListGroup: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtListGroupUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 381
///
/// `MustStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmtSuffixSemicolon {}

///
/// Type derived for production 382
///
/// `MustStmtSuffix: LBrace^ /* Clipped */ MustStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmtSuffixLBraceMustStmtListRBrace<'t> {
    pub must_stmt_list: Vec<MustStmtList<'t>>,
}

///
/// Type derived for production 384
///
/// `MustStmtListGroup: ErrorMessage;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmtListGroupErrorMessage<'t> {
    pub error_message: Box<ErrorMessage<'t>>,
}

///
/// Type derived for production 385
///
/// `MustStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 391
///
/// `MandatoryArgStr: MandatoryArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MandatoryArgStrMandatoryArg<'t> {
    pub mandatory_arg: Box<MandatoryArg<'t>>,
}

///
/// Type derived for production 392
///
/// `MandatoryArgStr: <Mandatory>'"' MandatoryArg <Mandatory>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MandatoryArgStrDoubleQuotationMandatoryArgDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub mandatory_arg: Box<MandatoryArg<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 396
///
/// `ListStmtListGroup: WhenStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupWhenStmt<'t> {
    pub when_stmt: Box<WhenStmt<'t>>,
}

///
/// Type derived for production 397
///
/// `ListStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 398
///
/// `ListStmtListGroup: MustStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupMustStmt<'t> {
    pub must_stmt: Box<MustStmt<'t>>,
}

///
/// Type derived for production 399
///
/// `ListStmtListGroup: KeyStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupKeyStmt<'t> {
    pub key_stmt: Box<KeyStmt<'t>>,
}

///
/// Type derived for production 400
///
/// `ListStmtListGroup: ConfigStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupConfigStmt<'t> {
    pub config_stmt: Box<ConfigStmt<'t>>,
}

///
/// Type derived for production 401
///
/// `ListStmtListGroup: MinElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupMinElementsStmt<'t> {
    pub min_elements_stmt: Box<MinElementsStmt<'t>>,
}

///
/// Type derived for production 402
///
/// `ListStmtListGroup: MaxElementsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupMaxElementsStmt<'t> {
    pub max_elements_stmt: Box<MaxElementsStmt<'t>>,
}

///
/// Type derived for production 403
///
/// `ListStmtListGroup: OrderedByStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupOrderedByStmt<'t> {
    pub ordered_by_stmt: Box<OrderedByStmt<'t>>,
}

///
/// Type derived for production 404
///
/// `ListStmtListGroup: StatusStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupStatusStmt<'t> {
    pub status_stmt: Box<StatusStmt<'t>>,
}

///
/// Type derived for production 405
///
/// `ListStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 406
///
/// `ListStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 407
///
/// `ListStmtListGroup: DataDefStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupDataDefStmt<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for production 408
///
/// `ListStmtListGroup: ActionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupActionStmt<'t> {
    pub action_stmt: Box<ActionStmt<'t>>,
}

///
/// Type derived for production 409
///
/// `ListStmtListGroup: NotificationStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupNotificationStmt<'t> {
    pub notification_stmt: Box<NotificationStmt<'t>>,
}

///
/// Type derived for production 410
///
/// `ListStmtListGroup: UnknownStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtListGroupUnknownStmt<'t> {
    pub unknown_stmt: Box<UnknownStmt<'t>>,
}

///
/// Type derived for production 413
///
/// `OrderedByArgStr: OrderedByArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OrderedByArgStrOrderedByArg<'t> {
    pub ordered_by_arg: Box<OrderedByArg<'t>>,
}

///
/// Type derived for production 414
///
/// `OrderedByArgStr: <Ordered>'"' OrderedByArg <Ordered>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OrderedByArgStrDoubleQuotationOrderedByArgDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub ordered_by_arg: Box<OrderedByArg<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 417
///
/// `DefaultStmtSuffix: AsciiNoSemicolon Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DefaultStmtSuffixAsciiNoSemicolonSemicolon<'t> {
    pub ascii_no_semicolon: Box<AsciiNoSemicolon<'t>>,
}

///
/// Type derived for production 418
///
/// `DefaultStmtSuffix: <Default>'"' AsciiNoSemicolon <Default>'"' Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DefaultStmtSuffixDoubleQuotationAsciiNoSemicolonDoubleQuotationSemicolon<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub ascii_no_semicolon: Box<AsciiNoSemicolon<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 422
///
/// `TypeStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtSuffixSemicolon {}

///
/// Type derived for production 423
///
/// `TypeStmtSuffix: LBrace^ /* Clipped */ TypeStmtList /* Vec */ <INITIAL, Keyword>'}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtSuffixLBraceTypeStmtListRBrace<'t> {
    pub type_stmt_list: Vec<TypeStmtList<'t>>,
}

///
/// Type derived for production 425
///
/// `TypeStmtListGroup: FractionDigitsStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupFractionDigitsStmt<'t> {
    pub fraction_digits_stmt: Box<FractionDigitsStmt<'t>>,
}

///
/// Type derived for production 426
///
/// `TypeStmtListGroup: EnumStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupEnumStmt<'t> {
    pub enum_stmt: Box<EnumStmt<'t>>,
}

///
/// Type derived for production 427
///
/// `TypeStmtListGroup: BaseStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupBaseStmt<'t> {
    pub base_stmt: Box<BaseStmt<'t>>,
}

///
/// Type derived for production 428
///
/// `TypeStmtListGroup: LeafrefSpecification;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupLeafrefSpecification<'t> {
    pub leafref_specification: Box<LeafrefSpecification<'t>>,
}

///
/// Type derived for production 429
///
/// `TypeStmtListGroup: StringRestrictions;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupStringRestrictions<'t> {
    pub string_restrictions: Box<StringRestrictions<'t>>,
}

///
/// Type derived for production 430
///
/// `TypeStmtListGroup: RangeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupRangeStmt<'t> {
    pub range_stmt: Box<RangeStmt<'t>>,
}

///
/// Type derived for production 431
///
/// `TypeStmtListGroup: BitStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupBitStmt<'t> {
    pub bit_stmt: Box<BitStmt<'t>>,
}

///
/// Type derived for production 432
///
/// `TypeStmtListGroup: TypeStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtListGroupTypeStmt<'t> {
    pub type_stmt: Box<TypeStmt<'t>>,
}

///
/// Type derived for production 437
///
/// `BitStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtSuffixSemicolon {}

///
/// Type derived for production 438
///
/// `BitStmtSuffix: LBrace^ /* Clipped */ BitStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtSuffixLBraceBitStmtListRBrace<'t> {
    pub bit_stmt_list: Vec<BitStmtList<'t>>,
}

///
/// Type derived for production 440
///
/// `BitStmtListGroup: PositionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtListGroupPositionStmt<'t> {
    pub position_stmt: Box<PositionStmt<'t>>,
}

///
/// Type derived for production 441
///
/// `BitStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 442
///
/// `BitStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 445
///
/// `LeafrefSpecification: PathStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafrefSpecificationPathStmt<'t> {
    pub path_stmt: Box<PathStmt<'t>>,
}

///
/// Type derived for production 446
///
/// `LeafrefSpecification: RequireInstanceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafrefSpecificationRequireInstanceStmt<'t> {
    pub require_instance_stmt: Box<RequireInstanceStmt<'t>>,
}

///
/// Type derived for production 448
///
/// `RequireInstanceArgStr: MandatoryArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RequireInstanceArgStrMandatoryArg<'t> {
    pub mandatory_arg: Box<MandatoryArg<'t>>,
}

///
/// Type derived for production 449
///
/// `RequireInstanceArgStr: <Mandatory>'"' MandatoryArg <Mandatory>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RequireInstanceArgStrDoubleQuotationMandatoryArgDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub mandatory_arg: Box<MandatoryArg<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 451
///
/// `StringRestrictions: LengthStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringRestrictionsLengthStmt<'t> {
    pub length_stmt: Box<LengthStmt<'t>>,
}

///
/// Type derived for production 452
///
/// `StringRestrictions: PatternStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringRestrictionsPatternStmt<'t> {
    pub pattern_stmt: Box<PatternStmt<'t>>,
}

///
/// Type derived for production 456
///
/// `EnumStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtSuffixSemicolon {}

///
/// Type derived for production 457
///
/// `EnumStmtSuffix: LBrace^ /* Clipped */ EnumStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtSuffixLBraceEnumStmtListRBrace<'t> {
    pub enum_stmt_list: Vec<EnumStmtList<'t>>,
}

///
/// Type derived for production 459
///
/// `EnumStmtListGroup: IfFeatureStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtListGroupIfFeatureStmt<'t> {
    pub if_feature_stmt: Box<IfFeatureStmt<'t>>,
}

///
/// Type derived for production 460
///
/// `EnumStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 461
///
/// `EnumStmtListGroup: ValueStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtListGroupValueStmt<'t> {
    pub value_stmt: Box<ValueStmt<'t>>,
}

///
/// Type derived for production 462
///
/// `EnumStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 465
///
/// `IntegerValueStr: IntegerValue;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IntegerValueStrIntegerValue<'t> {
    pub integer_value: Box<IntegerValue<'t>>,
}

///
/// Type derived for production 466
///
/// `IntegerValueStr: <Value>'"' IntegerValue <Value>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IntegerValueStrDoubleQuotationIntegerValueDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub integer_value: Box<IntegerValue<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 468
///
/// `EnumArgStr: AsciiNoBrace;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumArgStrAsciiNoBrace<'t> {
    pub ascii_no_brace: Box<AsciiNoBrace<'t>>,
}

///
/// Type derived for production 469
///
/// `EnumArgStr: <Enum>'"'^ /* Clipped */ AsciiNoBrace <Enum>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumArgStrDoubleQuotationAsciiNoBraceDoubleQuotation<'t> {
    pub ascii_no_brace: Box<AsciiNoBrace<'t>>,
}

///
/// Type derived for production 471
///
/// `RangeArgStr: RangeArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeArgStrRangeArg<'t> {
    pub range_arg: Box<RangeArg<'t>>,
}

///
/// Type derived for production 472
///
/// `RangeArgStr: <Range>'"'^ /* Clipped */ RangeArg <Range>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeArgStrDoubleQuotationRangeArgDoubleQuotation<'t> {
    pub range_arg: Box<RangeArg<'t>>,
}

///
/// Type derived for production 479
///
/// `RangeBoundary: <Range>'min';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeBoundaryMin<'t> {
    pub min: Token<'t>, /* min */
}

///
/// Type derived for production 480
///
/// `RangeBoundary: <Range>'max';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeBoundaryMax<'t> {
    pub max: Token<'t>, /* max */
}

///
/// Type derived for production 481
///
/// `RangeBoundary: <Range>"-?[0-9]+";`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeBoundaryMinusQuestLBracket0Minus9RBracketPlus<'t> {
    pub minus_quest_l_bracket0_minus9_r_bracket_plus: Token<'t>, /* -?[0-9]+ */
}

///
/// Type derived for production 482
///
/// `IdentifierRefArgStr: IdentifierRef;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierRefArgStrIdentifierRef<'t> {
    pub identifier_ref: Box<IdentifierRef<'t>>,
}

///
/// Type derived for production 483
///
/// `IdentifierRefArgStr: <Keyword, IfFeature>'"' IdentifierRef <Keyword, IfFeature>'"';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierRefArgStrDoubleQuotationIdentifierRefDoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
    pub identifier_ref: Box<IdentifierRef<'t>>,
    pub double_quotation0: Token<'t>, /* " */
}

///
/// Type derived for production 488
///
/// `KeyArgStr: KeyArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyArgStrKeyArg<'t> {
    pub key_arg: Box<KeyArg<'t>>,
}

///
/// Type derived for production 489
///
/// `KeyArgStr: <Keyword>'"'^ /* Clipped */ KeyArg <Keyword>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyArgStrDoubleQuotationKeyArgDoubleQuotation<'t> {
    pub key_arg: Box<KeyArg<'t>>,
}

///
/// Type derived for production 497
///
/// `ImportStmtListGroup: PrefixStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmtListGroupPrefixStmt<'t> {
    pub prefix_stmt: Box<PrefixStmt<'t>>,
}

///
/// Type derived for production 498
///
/// `ImportStmtListGroup: RevisionDateStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmtListGroupRevisionDateStmt<'t> {
    pub revision_date_stmt: Box<RevisionDateStmt<'t>>,
}

///
/// Type derived for production 499
///
/// `ImportStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 500
///
/// `ImportStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 503
///
/// `IncludeStmtSuffix: Semicolon^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtSuffixSemicolon {}

///
/// Type derived for production 504
///
/// `IncludeStmtSuffix: LBrace^ /* Clipped */ IncludeStmtList /* Vec */ '}'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtSuffixLBraceIncludeStmtListRBrace<'t> {
    pub include_stmt_list: Vec<IncludeStmtList<'t>>,
}

///
/// Type derived for production 506
///
/// `IncludeStmtListGroup: RevisionDateStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtListGroupRevisionDateStmt<'t> {
    pub revision_date_stmt: Box<RevisionDateStmt<'t>>,
}

///
/// Type derived for production 507
///
/// `IncludeStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 508
///
/// `IncludeStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 512
///
/// `UriStr: UriArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UriStrUriArg<'t> {
    pub uri_arg: Box<UriArg<'t>>,
}

///
/// Type derived for production 513
///
/// `UriStr: <Uri>'"'^ /* Clipped */ UriArg <Uri>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UriStrDoubleQuotationUriArgDoubleQuotation<'t> {
    pub uri_arg: Box<UriArg<'t>>,
}

///
/// Type derived for production 523
///
/// `RevisionStmtListGroup: DescriptionStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RevisionStmtListGroupDescriptionStmt<'t> {
    pub description_stmt: Box<DescriptionStmt<'t>>,
}

///
/// Type derived for production 524
///
/// `RevisionStmtListGroup: ReferenceStmt;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RevisionStmtListGroupReferenceStmt<'t> {
    pub reference_stmt: Box<ReferenceStmt<'t>>,
}

///
/// Type derived for production 526
///
/// `DateArgStr: DateArg;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DateArgStrDateArg<'t> {
    pub date_arg: Box<DateArg<'t>>,
}

///
/// Type derived for production 527
///
/// `DateArgStr: <Revision>'"'^ /* Clipped */ DateArg <Revision>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DateArgStrDoubleQuotationDateArgDoubleQuotation<'t> {
    pub date_arg: Box<DateArg<'t>>,
}

///
/// Type derived for production 529
///
/// `Ystring: BasicString YstringOpt /* Option */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YstringBasicStringYstringOpt<'t> {
    pub basic_string: Box<BasicString<'t>>,
    pub ystring_opt: Option<YstringOpt<'t>>,
}

///
/// Type derived for production 530
///
/// `Ystring: Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YstringIdentifier<'t> {
    pub identifier: Box<Identifier<'t>>,
}

///
/// Type derived for production 533
///
/// `BasicString: DQString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BasicStringDQString<'t> {
    pub d_q_string: Box<DQString<'t>>,
}

///
/// Type derived for production 534
///
/// `BasicString: SQString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BasicStringSQString<'t> {
    pub s_q_string: Box<SQString<'t>>,
}

///
/// Type derived for production 539
///
/// `DQChar: DQUnescaped;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQCharDQUnescaped<'t> {
    pub d_q_unescaped: Box<DQUnescaped<'t>>,
}

///
/// Type derived for production 540
///
/// `DQChar: DQEscaped;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQCharDQEscaped<'t> {
    pub d_q_escaped: Box<DQEscaped<'t>>,
}

///
/// Type derived for production 541
///
/// `DQUnescaped: DQNoEscape;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQUnescapedDQNoEscape<'t> {
    pub d_q_no_escape: Box<DQNoEscape<'t>>,
}

///
/// Type derived for production 542
///
/// `DQUnescaped: NonAscii;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQUnescapedNonAscii<'t> {
    pub non_ascii: Box<NonAscii<'t>>,
}

///
/// Type derived for production 544
///
/// `DQEscapeSeqChar: Escape;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQEscapeSeqCharEscape<'t> {
    pub escape: Box<Escape<'t>>,
}

///
/// Type derived for production 545
///
/// `DQEscapeSeqChar: DoubleQuotation;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQEscapeSeqCharDoubleQuotation<'t> {
    pub double_quotation: Box<DoubleQuotation<'t>>,
}

///
/// Type derived for production 546
///
/// `DQEscapeSeqChar: EscN;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQEscapeSeqCharEscN<'t> {
    pub esc_n: Box<EscN<'t>>,
}

///
/// Type derived for production 547
///
/// `DQEscapeSeqChar: EscT;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQEscapeSeqCharEscT<'t> {
    pub esc_t: Box<EscT<'t>>,
}

///
/// Type derived for production 554
///
/// `SQChar: SQUnescaped;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQCharSQUnescaped<'t> {
    pub s_q_unescaped: Box<SQUnescaped<'t>>,
}

///
/// Type derived for production 555
///
/// `SQChar: SQEscaped;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQCharSQEscaped<'t> {
    pub s_q_escaped: Box<SQEscaped<'t>>,
}

///
/// Type derived for production 558
///
/// `SQUnescaped: SQNoEscape;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQUnescapedSQNoEscape<'t> {
    pub s_q_no_escape: Box<SQNoEscape<'t>>,
}

///
/// Type derived for production 559
///
/// `SQUnescaped: NonAscii;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQUnescapedNonAscii<'t> {
    pub non_ascii: Box<NonAscii<'t>>,
}

///
/// Type derived for production 562
///
/// `IdentifierArgStr: Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierArgStrIdentifier<'t> {
    pub identifier: Box<Identifier<'t>>,
}

///
/// Type derived for production 563
///
/// `IdentifierArgStr: <Keyword>'"'^ /* Clipped */ Identifier <Keyword>'"'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierArgStrDoubleQuotationIdentifierDoubleQuotation<'t> {
    pub identifier: Box<Identifier<'t>>,
}

// -------------------------------------------------------------------------------------------------
//
// Types of non-terminals deduced from the structure of the transformed grammar
//

///
/// Type derived for non-terminal AbsoluteSchemaNodeid
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AbsoluteSchemaNodeid<'t> {
    pub slash: Token<'t>, /* / */
    pub identifier_ref: Box<IdentifierRef<'t>>,
}

///
/// Type derived for non-terminal ActionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub action_stmt_suffix: Box<ActionStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal ActionStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ActionStmtList<'t> {
    pub action_stmt_list_group: Box<ActionStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ActionStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ActionStmtListGroup<'t> {
    IfFeatureStmt(ActionStmtListGroupIfFeatureStmt<'t>),
    StatusStmt(ActionStmtListGroupStatusStmt<'t>),
    DescriptionStmt(ActionStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ActionStmtListGroupReferenceStmt<'t>),
    InputStmt(ActionStmtListGroupInputStmt<'t>),
    OutputStmt(ActionStmtListGroupOutputStmt<'t>),
}

///
/// Type derived for non-terminal ActionStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ActionStmtSuffix<'t> {
    Semicolon(ActionStmtSuffixSemicolon<'t>),
    LBraceActionStmtListRBrace(ActionStmtSuffixLBraceActionStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal AnydataStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub anydata_stmt_suffix: Box<AnydataStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal AnydataStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnydataStmtList<'t> {
    pub anydata_stmt_list_group: Box<AnydataStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal AnydataStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum AnydataStmtListGroup<'t> {
    WhenStmt(AnydataStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(AnydataStmtListGroupIfFeatureStmt<'t>),
    MustStmt(AnydataStmtListGroupMustStmt<'t>),
    ConfigStmt(AnydataStmtListGroupConfigStmt<'t>),
    MandatoryStmt(AnydataStmtListGroupMandatoryStmt<'t>),
    StatusStmt(AnydataStmtListGroupStatusStmt<'t>),
    DescriptionStmt(AnydataStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(AnydataStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal AnydataStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum AnydataStmtSuffix<'t> {
    Semicolon(AnydataStmtSuffixSemicolon),
    LBraceAnydataStmtListRBrace(AnydataStmtSuffixLBraceAnydataStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal AnyxmlStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub anyxml_stmt_suffix: Box<AnyxmlStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal AnyxmlStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnyxmlStmtList<'t> {
    pub anyxml_stmt_list_group: Box<AnyxmlStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal AnyxmlStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum AnyxmlStmtListGroup<'t> {
    WhenStmt(AnyxmlStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(AnyxmlStmtListGroupIfFeatureStmt<'t>),
    MustStmt(AnyxmlStmtListGroupMustStmt<'t>),
    ConfigStmt(AnyxmlStmtListGroupConfigStmt<'t>),
    MandatoryStmt(AnyxmlStmtListGroupMandatoryStmt<'t>),
    StatusStmt(AnyxmlStmtListGroupStatusStmt<'t>),
    DescriptionStmt(AnyxmlStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(AnyxmlStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal AnyxmlStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum AnyxmlStmtSuffix<'t> {
    Semicolon(AnyxmlStmtSuffixSemicolon),
    LBraceAnyxmlStmtListRBrace(AnyxmlStmtSuffixLBraceAnyxmlStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal ArgumentStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArgumentStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
}

///
/// Type derived for non-terminal AsciiNoBrace
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AsciiNoBrace<'t> {
    pub ascii_no_brace: Token<'t>, /* [\t\u{21}\u{23}-\u{3a}\u{3c}-\u{5b}\u{5d}-\u{7a}\u{7c}\u{7e}]+ */
}

///
/// Type derived for non-terminal AsciiNoSemicolon
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AsciiNoSemicolon<'t> {
    pub ascii_no_semicolon: Token<'t>, /* [ \t\u{21}\u{23}-\u{3a}\u{3c}-\u{5b}\u{5d}-\u{7e}]+ */
}

///
/// Type derived for non-terminal AugmentArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentArgStr<'t> {
    pub ystring: Box<Ystring<'t>>,
}

///
/// Type derived for non-terminal AugmentStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmt<'t> {
    pub augment_arg_str: Box<AugmentArgStr<'t>>,
    pub augment_stmt_list: Vec<AugmentStmtList<'t>>,
}

///
/// Type derived for non-terminal AugmentStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AugmentStmtList<'t> {
    pub augment_stmt_list_group: Box<AugmentStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal AugmentStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum AugmentStmtListGroup<'t> {
    WhenStmt(AugmentStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(AugmentStmtListGroupIfFeatureStmt<'t>),
    StatusStmt(AugmentStmtListGroupStatusStmt<'t>),
    DescriptionStmt(AugmentStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(AugmentStmtListGroupReferenceStmt<'t>),
    DataDefStmt(AugmentStmtListGroupDataDefStmt<'t>),
    CaseStmt(AugmentStmtListGroupCaseStmt<'t>),
    ActionStmt(AugmentStmtListGroupActionStmt<'t>),
    NotificationStmt(AugmentStmtListGroupNotificationStmt<'t>),
}

///
/// Type derived for non-terminal BaseStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BaseStmt<'t> {
    pub identifier_ref_arg_str: Box<IdentifierRefArgStr<'t>>,
}

///
/// Type derived for non-terminal BasicString
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum BasicString<'t> {
    DQString(BasicStringDQString<'t>),
    SQString(BasicStringSQString<'t>),
}

///
/// Type derived for non-terminal BelongsToStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BelongsToStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub prefix_stmt: Box<PrefixStmt<'t>>,
}

///
/// Type derived for non-terminal BitStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub bit_stmt_suffix: Box<BitStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal BitStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BitStmtList<'t> {
    pub bit_stmt_list_group: Box<BitStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal BitStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum BitStmtListGroup<'t> {
    PositionStmt(BitStmtListGroupPositionStmt<'t>),
    DescriptionStmt(BitStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(BitStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal BitStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum BitStmtSuffix<'t> {
    Semicolon(BitStmtSuffixSemicolon),
    LBraceBitStmtListRBrace(BitStmtSuffixLBraceBitStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal BodyStmts
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum BodyStmts<'t> {
    ExtensionStmt(BodyStmtsExtensionStmt<'t>),
    FeatureStmt(BodyStmtsFeatureStmt<'t>),
    IdentityStmt(BodyStmtsIdentityStmt<'t>),
    TypedefStmt(BodyStmtsTypedefStmt<'t>),
    GroupingStmt(BodyStmtsGroupingStmt<'t>),
    DataDefStmt(BodyStmtsDataDefStmt<'t>),
    AugmentStmt(BodyStmtsAugmentStmt<'t>),
    RpcStmt(BodyStmtsRpcStmt<'t>),
    NotificationStmt(BodyStmtsNotificationStmt<'t>),
    DeviationStmt(BodyStmtsDeviationStmt<'t>),
    UnknownStmt(BodyStmtsUnknownStmt<'t>),
}

///
/// Type derived for non-terminal CaseStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub case_stmt_suffix: Box<CaseStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal CaseStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CaseStmtList<'t> {
    pub case_stmt_list_group: Box<CaseStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal CaseStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CaseStmtListGroup<'t> {
    WhenStmt(CaseStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(CaseStmtListGroupIfFeatureStmt<'t>),
    DataDefStmt(CaseStmtListGroupDataDefStmt<'t>),
    DescriptionStmt(CaseStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(CaseStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal CaseStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CaseStmtSuffix<'t> {
    Semicolon(CaseStmtSuffixSemicolon),
    LBraceCaseStmtListRBrace(CaseStmtSuffixLBraceCaseStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal ChoiceStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmt<'t> {
    pub identifier_ref_arg_str: Box<IdentifierRefArgStr<'t>>,
    pub choice_stmt_suffix: Box<ChoiceStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal ChoiceStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ChoiceStmtList<'t> {
    pub choice_stmt_list_group: Box<ChoiceStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ChoiceStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ChoiceStmtListGroup<'t> {
    WhenStmt(ChoiceStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(ChoiceStmtListGroupIfFeatureStmt<'t>),
    DefaultStmt(ChoiceStmtListGroupDefaultStmt<'t>),
    ConfigStmt(ChoiceStmtListGroupConfigStmt<'t>),
    MandatoryStmt(ChoiceStmtListGroupMandatoryStmt<'t>),
    StatusStmt(ChoiceStmtListGroupStatusStmt<'t>),
    DescriptionStmt(ChoiceStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ChoiceStmtListGroupReferenceStmt<'t>),
    ShortCaseStmt(ChoiceStmtListGroupShortCaseStmt<'t>),
    CaseStmt(ChoiceStmtListGroupCaseStmt<'t>),
}

///
/// Type derived for non-terminal ChoiceStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ChoiceStmtSuffix<'t> {
    Semicolon(ChoiceStmtSuffixSemicolon),
    LBraceChoiceStmtListRBrace(ChoiceStmtSuffixLBraceChoiceStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal ConfigStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ConfigStmt<'t> {
    pub mandatory_arg_str: Box<MandatoryArgStr<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal ContactStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContactStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal ContainerStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub container_stmt_suffix: Box<ContainerStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal ContainerStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ContainerStmtList<'t> {
    pub container_stmt_list_group: Box<ContainerStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ContainerStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ContainerStmtListGroup<'t> {
    WhenStmt(ContainerStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(ContainerStmtListGroupIfFeatureStmt<'t>),
    MustStmt(ContainerStmtListGroupMustStmt<'t>),
    PresenceStmt(ContainerStmtListGroupPresenceStmt<'t>),
    ConfigStmt(ContainerStmtListGroupConfigStmt<'t>),
    StatusStmt(ContainerStmtListGroupStatusStmt<'t>),
    DescriptionStmt(ContainerStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ContainerStmtListGroupReferenceStmt<'t>),
    DataDefStmt(ContainerStmtListGroupDataDefStmt<'t>),
    ActionStmt(ContainerStmtListGroupActionStmt<'t>),
    NotificationStmt(ContainerStmtListGroupNotificationStmt<'t>),
    UnknownStmt(ContainerStmtListGroupUnknownStmt<'t>),
}

///
/// Type derived for non-terminal ContainerStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ContainerStmtSuffix<'t> {
    Semicolon(ContainerStmtSuffixSemicolon),
    LBraceContainerStmtListRBrace(ContainerStmtSuffixLBraceContainerStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal DQChar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DQChar<'t> {
    DQUnescaped(DQCharDQUnescaped<'t>),
    DQEscaped(DQCharDQEscaped<'t>),
}

///
/// Type derived for non-terminal DQEscapeSeqChar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DQEscapeSeqChar<'t> {
    Escape(DQEscapeSeqCharEscape<'t>),
    DoubleQuotation(DQEscapeSeqCharDoubleQuotation<'t>),
    EscN(DQEscapeSeqCharEscN<'t>),
    EscT(DQEscapeSeqCharEscT<'t>),
}

///
/// Type derived for non-terminal DQEscaped
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQEscaped<'t> {
    pub escape: Box<Escape<'t>>,
    pub d_q_escape_seq_char: Box<DQEscapeSeqChar<'t>>,
}

///
/// Type derived for non-terminal DQNoEscape
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQNoEscape<'t> {
    pub d_q_no_escape: Token<'t>, /* [ \n\r\t\u{21}\u{23}-\u{5B}\u{5D}-\u{7E}]+ */
}

///
/// Type derived for non-terminal DQString
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQString<'t> {
    pub d_q_string_list: Vec<DQStringList<'t>>,
}

///
/// Type derived for non-terminal DQStringList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DQStringList<'t> {
    pub d_q_char: Box<DQChar<'t>>,
}

///
/// Type derived for non-terminal DQUnescaped
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DQUnescaped<'t> {
    DQNoEscape(DQUnescapedDQNoEscape<'t>),
    NonAscii(DQUnescapedNonAscii<'t>),
}

///
/// Type derived for non-terminal DataDefStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DataDefStmt<'t> {
    ContainerStmt(DataDefStmtContainerStmt<'t>),
    LeafStmt(DataDefStmtLeafStmt<'t>),
    LeafListStmt(DataDefStmtLeafListStmt<'t>),
    ListStmt(DataDefStmtListStmt<'t>),
    ChoiceStmt(DataDefStmtChoiceStmt<'t>),
    AnydataStmt(DataDefStmtAnydataStmt<'t>),
    AnyxmlStmt(DataDefStmtAnyxmlStmt<'t>),
    UsesStmt(DataDefStmtUsesStmt<'t>),
}

///
/// Type derived for non-terminal DateArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DateArg<'t> {
    pub date_arg: Token<'t>, /* \d{4}-\d{2}-\d{2} */
}

///
/// Type derived for non-terminal DateArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DateArgStr<'t> {
    DateArg(DateArgStrDateArg<'t>),
    DoubleQuotationDateArgDoubleQuotation(DateArgStrDoubleQuotationDateArgDoubleQuotation<'t>),
}

///
/// Type derived for non-terminal DefaultStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DefaultStmt<'t> {
    pub default_stmt_suffix: Box<DefaultStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal DefaultStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DefaultStmtSuffix<'t> {
    AsciiNoSemicolonSemicolon(DefaultStmtSuffixAsciiNoSemicolonSemicolon<'t>),
    DoubleQuotationAsciiNoSemicolonDoubleQuotationSemicolon(
        DefaultStmtSuffixDoubleQuotationAsciiNoSemicolonDoubleQuotationSemicolon<'t>,
    ),
}

///
/// Type derived for non-terminal DescendantSchemaNodeid
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DescendantSchemaNodeid<'t> {
    IdentifierRef(DescendantSchemaNodeidIdentifierRef<'t>),
    AbsoluteSchemaNodeid(DescendantSchemaNodeidAbsoluteSchemaNodeid<'t>),
}

///
/// Type derived for non-terminal DescriptionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DescriptionStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
}

///
/// Type derived for non-terminal DeviationStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeviationStmt<'t> {
    pub absolute_schema_nodeid: Box<AbsoluteSchemaNodeid<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal DoubleQuotation
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DoubleQuotation<'t> {
    pub double_quotation: Token<'t>, /* " */
}

///
/// Type derived for non-terminal EnumArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum EnumArgStr<'t> {
    AsciiNoBrace(EnumArgStrAsciiNoBrace<'t>),
    DoubleQuotationAsciiNoBraceDoubleQuotation(
        EnumArgStrDoubleQuotationAsciiNoBraceDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal EnumStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmt<'t> {
    pub enum_arg_str: Box<EnumArgStr<'t>>,
    pub enum_stmt_suffix: Box<EnumStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal EnumStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EnumStmtList<'t> {
    pub enum_stmt_list_group: Box<EnumStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal EnumStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum EnumStmtListGroup<'t> {
    IfFeatureStmt(EnumStmtListGroupIfFeatureStmt<'t>),
    DescriptionStmt(EnumStmtListGroupDescriptionStmt<'t>),
    ValueStmt(EnumStmtListGroupValueStmt<'t>),
    ReferenceStmt(EnumStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal EnumStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum EnumStmtSuffix<'t> {
    Semicolon(EnumStmtSuffixSemicolon),
    LBraceEnumStmtListRBrace(EnumStmtSuffixLBraceEnumStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal ErrorMessage
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ErrorMessage<'t> {
    pub error_minus_message: Token<'t>, /* error-message */
    pub ystring: Box<Ystring<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal EscN
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EscN<'t> {
    pub esc_n: Token<'t>, /* n */
}

///
/// Type derived for non-terminal EscT
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct EscT<'t> {
    pub esc_t: Token<'t>, /* t */
}

///
/// Type derived for non-terminal Escape
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Escape<'t> {
    pub escape: Token<'t>, /* \u{5C} */
}

///
/// Type derived for non-terminal ExtensionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub extension_stmt_suffix: Box<ExtensionStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal ExtensionStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionStmtList<'t> {
    pub extension_stmt_list_group: Box<ExtensionStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ExtensionStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ExtensionStmtListGroup<'t> {
    ArgumentStmt(ExtensionStmtListGroupArgumentStmt<'t>),
    StatusStmt(ExtensionStmtListGroupStatusStmt<'t>),
    DescriptionStmt(ExtensionStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ExtensionStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal ExtensionStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ExtensionStmtSuffix<'t> {
    Semicolon(ExtensionStmtSuffixSemicolon),
    LBraceExtensionStmtListRBrace(ExtensionStmtSuffixLBraceExtensionStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal FeatureStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub feature_stmt_suffix: Box<FeatureStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal FeatureStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FeatureStmtList<'t> {
    pub feature_stmt_list_group: Box<FeatureStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal FeatureStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum FeatureStmtListGroup<'t> {
    IfFeatureStmt(FeatureStmtListGroupIfFeatureStmt<'t>),
    StatusStmt(FeatureStmtListGroupStatusStmt<'t>),
    DescriptionStmt(FeatureStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(FeatureStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal FeatureStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum FeatureStmtSuffix<'t> {
    Semicolon(FeatureStmtSuffixSemicolon),
    LBraceFeatureStmtListRBrace(FeatureStmtSuffixLBraceFeatureStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal FractionDigitsArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FractionDigitsArg<'t> {
    pub fraction_digits_arg: Token<'t>, /* 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18| */
}

///
/// Type derived for non-terminal FractionDigitsStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FractionDigitsStmt<'t> {
    pub fraction_digits_arg: Box<FractionDigitsArg<'t>>,
}

///
/// Type derived for non-terminal GroupingStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub grouping_stmt_list: Vec<GroupingStmtList<'t>>,
}

///
/// Type derived for non-terminal GroupingStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GroupingStmtList<'t> {
    pub grouping_stmt_list_group: Box<GroupingStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal GroupingStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum GroupingStmtListGroup<'t> {
    StatusStmt(GroupingStmtListGroupStatusStmt<'t>),
    DescriptionStmt(GroupingStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(GroupingStmtListGroupReferenceStmt<'t>),
    TypedefStmt(GroupingStmtListGroupTypedefStmt<'t>),
    GroupingStmt(GroupingStmtListGroupGroupingStmt<'t>),
    DataDefStmt(GroupingStmtListGroupDataDefStmt<'t>),
    ActionStmt(GroupingStmtListGroupActionStmt<'t>),
    NotificationStmt(GroupingStmtListGroupNotificationStmt<'t>),
    UnknownStmt(GroupingStmtListGroupUnknownStmt<'t>),
}

///
/// Type derived for non-terminal Identifier
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Identifier<'t> {
    pub identifier: Token<'t>, /* [a-zA-Z_][a-zA-Z0-9_\-\/\.:]* */
}

///
/// Type derived for non-terminal IdentifierArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IdentifierArgStr<'t> {
    Identifier(IdentifierArgStrIdentifier<'t>),
    DoubleQuotationIdentifierDoubleQuotation(
        IdentifierArgStrDoubleQuotationIdentifierDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal IdentifierRef
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierRef<'t> {
    pub identifier_ref_opt: Option<IdentifierRefOpt<'t>>,
    pub identifier: Box<Identifier<'t>>,
}

///
/// Type derived for non-terminal IdentifierRefArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IdentifierRefArgStr<'t> {
    IdentifierRef(IdentifierRefArgStrIdentifierRef<'t>),
    DoubleQuotationIdentifierRefDoubleQuotation(
        IdentifierRefArgStrDoubleQuotationIdentifierRefDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal IdentifierRefOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierRefOpt<'t> {
    pub identifier: Box<Identifier<'t>>,
    pub colon: Token<'t>, /* : */
}

///
/// Type derived for non-terminal IdentityStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub identity_stmt_list: Vec<IdentityStmtList<'t>>,
}

///
/// Type derived for non-terminal IdentityStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentityStmtList<'t> {
    pub identity_stmt_list_group: Box<IdentityStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal IdentityStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IdentityStmtListGroup<'t> {
    IfFeatureStmt(IdentityStmtListGroupIfFeatureStmt<'t>),
    BaseStmt(IdentityStmtListGroupBaseStmt<'t>),
    DescriptionStmt(IdentityStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(IdentityStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal IfFeatureExpr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureExpr<'t> {
    pub if_feature_term: Box<IfFeatureTerm<'t>>,
    pub if_feature_expr_opt: Option<IfFeatureExprOpt<'t>>,
}

///
/// Type derived for non-terminal IfFeatureExprOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureExprOpt<'t> {
    pub or: Token<'t>, /* or */
    pub if_feature_expr: Box<IfFeatureExpr<'t>>,
}

///
/// Type derived for non-terminal IfFeatureExprStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureExprStr<'t> {
    pub if_feature_expr: Box<IfFeatureExpr<'t>>,
}

///
/// Type derived for non-terminal IfFeatureFactor
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IfFeatureFactor<'t> {
    NotIfFeatureFactor(IfFeatureFactorNotIfFeatureFactor<'t>),
    LParenIfFeatureExprRParen(IfFeatureFactorLParenIfFeatureExprRParen<'t>),
    Identifier(IfFeatureFactorIdentifier<'t>),
    DoubleQuotationIdentifierDoubleQuotation(
        IfFeatureFactorDoubleQuotationIdentifierDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal IfFeatureStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureStmt<'t> {
    pub if_feature_expr_str: Box<IfFeatureExprStr<'t>>,
}

///
/// Type derived for non-terminal IfFeatureTerm
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureTerm<'t> {
    pub if_feature_factor: Box<IfFeatureFactor<'t>>,
    pub if_feature_term_opt: Option<IfFeatureTermOpt<'t>>,
}

///
/// Type derived for non-terminal IfFeatureTermOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IfFeatureTermOpt<'t> {
    pub and: Token<'t>, /* and */
    pub if_feature_term: Box<IfFeatureTerm<'t>>,
}

///
/// Type derived for non-terminal ImportStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub import_stmt_list: Vec<ImportStmtList<'t>>,
}

///
/// Type derived for non-terminal ImportStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ImportStmtList<'t> {
    pub import_stmt_list_group: Box<ImportStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ImportStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ImportStmtListGroup<'t> {
    PrefixStmt(ImportStmtListGroupPrefixStmt<'t>),
    RevisionDateStmt(ImportStmtListGroupRevisionDateStmt<'t>),
    DescriptionStmt(ImportStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ImportStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal IncludeStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub include_stmt_suffix: Box<IncludeStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal IncludeStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IncludeStmtList<'t> {
    pub include_stmt_list_group: Box<IncludeStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal IncludeStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IncludeStmtListGroup<'t> {
    RevisionDateStmt(IncludeStmtListGroupRevisionDateStmt<'t>),
    DescriptionStmt(IncludeStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(IncludeStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal IncludeStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IncludeStmtSuffix<'t> {
    Semicolon(IncludeStmtSuffixSemicolon),
    LBraceIncludeStmtListRBrace(IncludeStmtSuffixLBraceIncludeStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal InputStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct InputStmt<'t> {
    pub input: Token<'t>, /* input */
    pub input_stmt_list: Vec<InputStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for non-terminal InputStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct InputStmtList<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for non-terminal IntegerValue
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IntegerValue<'t> {
    pub integer_value: Token<'t>, /* [0-9]+ */
}

///
/// Type derived for non-terminal IntegerValueStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum IntegerValueStr<'t> {
    IntegerValue(IntegerValueStrIntegerValue<'t>),
    DoubleQuotationIntegerValueDoubleQuotation(
        IntegerValueStrDoubleQuotationIntegerValueDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal KeyArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyArg<'t> {
    pub identifier_ref: Box<IdentifierRef<'t>>,
    pub key_arg_opt: Option<KeyArgOpt<'t>>,
}

///
/// Type derived for non-terminal KeyArgOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyArgOpt<'t> {
    pub key_arg: Box<KeyArg<'t>>,
}

///
/// Type derived for non-terminal KeyArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum KeyArgStr<'t> {
    KeyArg(KeyArgStrKeyArg<'t>),
    DoubleQuotationKeyArgDoubleQuotation(KeyArgStrDoubleQuotationKeyArgDoubleQuotation<'t>),
}

///
/// Type derived for non-terminal KeyStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyStmt<'t> {
    pub key_arg_str: Box<KeyArgStr<'t>>,
}

///
/// Type derived for non-terminal KwAction
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwAction<'t> {
    pub kw_action: Token<'t>, /* action */
}

///
/// Type derived for non-terminal KwAnydata
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwAnydata<'t> {
    pub kw_anydata: Token<'t>, /* anydata */
}

///
/// Type derived for non-terminal KwAnyxml
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwAnyxml<'t> {
    pub kw_anyxml: Token<'t>, /* anyxml */
}

///
/// Type derived for non-terminal KwArgument
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwArgument<'t> {
    pub kw_argument: Token<'t>, /* argument */
}

///
/// Type derived for non-terminal KwBase
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwBase<'t> {
    pub kw_base: Token<'t>, /* base */
}

///
/// Type derived for non-terminal KwBelongsTo
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwBelongsTo<'t> {
    pub kw_belongs_to: Token<'t>, /* belongs-to */
}

///
/// Type derived for non-terminal KwBit
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwBit<'t> {
    pub kw_bit: Token<'t>, /* bit */
}

///
/// Type derived for non-terminal KwCase
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwCase<'t> {
    pub kw_case: Token<'t>, /* case */
}

///
/// Type derived for non-terminal KwChoice
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwChoice<'t> {
    pub kw_choice: Token<'t>, /* choice */
}

///
/// Type derived for non-terminal KwConfig
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwConfig<'t> {
    pub kw_config: Token<'t>, /* config */
}

///
/// Type derived for non-terminal KwContainer
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwContainer<'t> {
    pub kw_container: Token<'t>, /* container */
}

///
/// Type derived for non-terminal KwDefault
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwDefault<'t> {
    pub kw_default: Token<'t>, /* default */
}

///
/// Type derived for non-terminal KwDeviation
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwDeviation<'t> {
    pub kw_deviation: Token<'t>, /* deviation */
}

///
/// Type derived for non-terminal KwEnum
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwEnum<'t> {
    pub kw_enum: Token<'t>, /* enum */
}

///
/// Type derived for non-terminal KwExtension
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwExtension<'t> {
    pub kw_extension: Token<'t>, /* extension */
}

///
/// Type derived for non-terminal KwFeature
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwFeature<'t> {
    pub kw_feature: Token<'t>, /* feature */
}

///
/// Type derived for non-terminal KwFractionDigits
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwFractionDigits<'t> {
    pub kw_fraction_digits: Token<'t>, /* fraction-digits */
}

///
/// Type derived for non-terminal KwGrouping
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwGrouping<'t> {
    pub kw_grouping: Token<'t>, /* grouping */
}

///
/// Type derived for non-terminal KwIdentity
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwIdentity<'t> {
    pub kw_identity: Token<'t>, /* identity */
}

///
/// Type derived for non-terminal KwIfFeature
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwIfFeature<'t> {
    pub kw_if_feature: Token<'t>, /* if-feature */
}

///
/// Type derived for non-terminal KwImport
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwImport<'t> {
    pub kw_import: Token<'t>, /* import */
}

///
/// Type derived for non-terminal KwInclude
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwInclude<'t> {
    pub kw_include: Token<'t>, /* include */
}

///
/// Type derived for non-terminal KwKey
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwKey<'t> {
    pub kw_key: Token<'t>, /* key */
}

///
/// Type derived for non-terminal KwLeaf
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwLeaf<'t> {
    pub kw_leaf: Token<'t>, /* leaf */
}

///
/// Type derived for non-terminal KwLeafList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwLeafList<'t> {
    pub kw_leaf_list: Token<'t>, /* leaf-list */
}

///
/// Type derived for non-terminal KwLength
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwLength<'t> {
    pub kw_length: Token<'t>, /* length */
}

///
/// Type derived for non-terminal KwList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwList<'t> {
    pub kw_list: Token<'t>, /* list */
}

///
/// Type derived for non-terminal KwMandatory
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwMandatory<'t> {
    pub kw_mandatory: Token<'t>, /* mandatory */
}

///
/// Type derived for non-terminal KwModule
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwModule<'t> {
    pub kw_module: Token<'t>, /* module */
}

///
/// Type derived for non-terminal KwNamespace
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwNamespace<'t> {
    pub kw_namespace: Token<'t>, /* namespace */
}

///
/// Type derived for non-terminal KwNotification
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwNotification<'t> {
    pub kw_notification: Token<'t>, /* notification */
}

///
/// Type derived for non-terminal KwOrderedBy
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwOrderedBy<'t> {
    pub kw_ordered_by: Token<'t>, /* ordered-by */
}

///
/// Type derived for non-terminal KwPosition
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwPosition<'t> {
    pub kw_position: Token<'t>, /* position */
}

///
/// Type derived for non-terminal KwPrefix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwPrefix<'t> {
    pub kw_prefix: Token<'t>, /* prefix */
}

///
/// Type derived for non-terminal KwRange
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRange<'t> {
    pub kw_range: Token<'t>, /* range */
}

///
/// Type derived for non-terminal KwRefine
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRefine<'t> {
    pub kw_refine: Token<'t>, /* refine */
}

///
/// Type derived for non-terminal KwRequireInstance
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRequireInstance<'t> {
    pub kw_require_instance: Token<'t>, /* require-instance */
}

///
/// Type derived for non-terminal KwRevision
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRevision<'t> {
    pub kw_revision: Token<'t>, /* revision */
}

///
/// Type derived for non-terminal KwRevisionDate
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRevisionDate<'t> {
    pub kw_revision_date: Token<'t>, /* revision-date */
}

///
/// Type derived for non-terminal KwRpc
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwRpc<'t> {
    pub kw_rpc: Token<'t>, /* rpc */
}

///
/// Type derived for non-terminal KwStatus
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwStatus<'t> {
    pub kw_status: Token<'t>, /* status */
}

///
/// Type derived for non-terminal KwSubmodule
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwSubmodule<'t> {
    pub kw_submodule: Token<'t>, /* submodule */
}

///
/// Type derived for non-terminal KwType
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwType<'t> {
    pub kw_type: Token<'t>, /* type */
}

///
/// Type derived for non-terminal KwTypedef
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwTypedef<'t> {
    pub kw_typedef: Token<'t>, /* typedef */
}

///
/// Type derived for non-terminal KwUses
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwUses<'t> {
    pub kw_uses: Token<'t>, /* uses */
}

///
/// Type derived for non-terminal KwValue
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwValue<'t> {
    pub kw_value: Token<'t>, /* value */
}

///
/// Type derived for non-terminal KwYangVersion
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KwYangVersion<'t> {
    pub kw_yang_version: Token<'t>, /* yang-version */
}

///
/// Type derived for non-terminal LBrace
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LBrace<'t> {
    pub l_brace: Token<'t>, /* { */
}

///
/// Type derived for non-terminal LeafListStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub leaf_list_stmt_list: Vec<LeafListStmtList<'t>>,
}

///
/// Type derived for non-terminal LeafListStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafListStmtList<'t> {
    pub leaf_list_stmt_list_group: Box<LeafListStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal LeafListStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LeafListStmtListGroup<'t> {
    WhenStmt(LeafListStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(LeafListStmtListGroupIfFeatureStmt<'t>),
    TypeStmt(LeafListStmtListGroupTypeStmt<'t>),
    UnitsStmt(LeafListStmtListGroupUnitsStmt<'t>),
    MustStmt(LeafListStmtListGroupMustStmt<'t>),
    DefaultStmt(LeafListStmtListGroupDefaultStmt<'t>),
    ConfigStmt(LeafListStmtListGroupConfigStmt<'t>),
    MinElementsStmt(LeafListStmtListGroupMinElementsStmt<'t>),
    MaxElementsStmt(LeafListStmtListGroupMaxElementsStmt<'t>),
    OrderedByStmt(LeafListStmtListGroupOrderedByStmt<'t>),
    StatusStmt(LeafListStmtListGroupStatusStmt<'t>),
    DescriptionStmt(LeafListStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(LeafListStmtListGroupReferenceStmt<'t>),
    UnknownStmt(LeafListStmtListGroupUnknownStmt<'t>),
}

///
/// Type derived for non-terminal LeafStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub leaf_stmt_list: Vec<LeafStmtList<'t>>,
}

///
/// Type derived for non-terminal LeafStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LeafStmtList<'t> {
    pub leaf_stmt_list_group: Box<LeafStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal LeafStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LeafStmtListGroup<'t> {
    WhenStmt(LeafStmtListGroupWhenStmt<'t>),
    StatusStmt(LeafStmtListGroupStatusStmt<'t>),
    IfFeatureStmt(LeafStmtListGroupIfFeatureStmt<'t>),
    TypeStmt(LeafStmtListGroupTypeStmt<'t>),
    UnitsStmt(LeafStmtListGroupUnitsStmt<'t>),
    MustStmt(LeafStmtListGroupMustStmt<'t>),
    DefaultStmt(LeafStmtListGroupDefaultStmt<'t>),
    ConfigStmt(LeafStmtListGroupConfigStmt<'t>),
    MandatoryStmt(LeafStmtListGroupMandatoryStmt<'t>),
    DescriptionStmt(LeafStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(LeafStmtListGroupReferenceStmt<'t>),
    UnknownStmt(LeafStmtListGroupUnknownStmt<'t>),
}

///
/// Type derived for non-terminal LeafrefSpecification
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LeafrefSpecification<'t> {
    PathStmt(LeafrefSpecificationPathStmt<'t>),
    RequireInstanceStmt(LeafrefSpecificationRequireInstanceStmt<'t>),
}

///
/// Type derived for non-terminal LengthStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LengthStmt<'t> {
    pub range_arg_str: Box<RangeArgStr<'t>>,
}

///
/// Type derived for non-terminal LinkageStmts
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LinkageStmts<'t> {
    ImportStmt(LinkageStmtsImportStmt<'t>),
    IncludeStmt(LinkageStmtsIncludeStmt<'t>),
}

///
/// Type derived for non-terminal ListStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub list_stmt_list: Vec<ListStmtList<'t>>,
}

///
/// Type derived for non-terminal ListStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ListStmtList<'t> {
    pub list_stmt_list_group: Box<ListStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal ListStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ListStmtListGroup<'t> {
    WhenStmt(ListStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(ListStmtListGroupIfFeatureStmt<'t>),
    MustStmt(ListStmtListGroupMustStmt<'t>),
    KeyStmt(ListStmtListGroupKeyStmt<'t>),
    ConfigStmt(ListStmtListGroupConfigStmt<'t>),
    MinElementsStmt(ListStmtListGroupMinElementsStmt<'t>),
    MaxElementsStmt(ListStmtListGroupMaxElementsStmt<'t>),
    OrderedByStmt(ListStmtListGroupOrderedByStmt<'t>),
    StatusStmt(ListStmtListGroupStatusStmt<'t>),
    DescriptionStmt(ListStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(ListStmtListGroupReferenceStmt<'t>),
    DataDefStmt(ListStmtListGroupDataDefStmt<'t>),
    ActionStmt(ListStmtListGroupActionStmt<'t>),
    NotificationStmt(ListStmtListGroupNotificationStmt<'t>),
    UnknownStmt(ListStmtListGroupUnknownStmt<'t>),
}

///
/// Type derived for non-terminal MandatoryArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MandatoryArg<'t> {
    pub mandatory_arg: Token<'t>, /* true|false */
}

///
/// Type derived for non-terminal MandatoryArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum MandatoryArgStr<'t> {
    MandatoryArg(MandatoryArgStrMandatoryArg<'t>),
    DoubleQuotationMandatoryArgDoubleQuotation(
        MandatoryArgStrDoubleQuotationMandatoryArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal MandatoryStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MandatoryStmt<'t> {
    pub mandatory_arg_str: Box<MandatoryArgStr<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal MaxElementsStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MaxElementsStmt<'t> {
    pub l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star: Token<'t>, /* [1-9][0-9]* */
}

///
/// Type derived for non-terminal MetaStmts
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum MetaStmts<'t> {
    OrganizationStmt(MetaStmtsOrganizationStmt<'t>),
    ContactStmt(MetaStmtsContactStmt<'t>),
    DescriptionStmt(MetaStmtsDescriptionStmt<'t>),
    ReferenceStmt(MetaStmtsReferenceStmt<'t>),
}

///
/// Type derived for non-terminal MinElementsStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MinElementsStmt<'t> {
    pub l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star: Token<'t>, /* [1-9][0-9]* */
}

///
/// Type derived for non-terminal ModuleHeaderStmts
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ModuleHeaderStmts<'t> {
    YangVersionStmt(ModuleHeaderStmtsYangVersionStmt<'t>),
    NamespaceStmt(ModuleHeaderStmtsNamespaceStmt<'t>),
    PrefixStmt(ModuleHeaderStmtsPrefixStmt<'t>),
}

///
/// Type derived for non-terminal ModuleStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub module_stmt_list: Vec<ModuleStmtList<'t>>,
    pub module_stmt_list0: Vec<ModuleStmtList0<'t>>,
    pub module_stmt_list1: Vec<ModuleStmtList1<'t>>,
    pub module_stmt_list2: Vec<ModuleStmtList2<'t>>,
    pub module_stmt_list3: Vec<ModuleStmtList3<'t>>,
}

///
/// Type derived for non-terminal ModuleStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmtList<'t> {
    pub module_header_stmts: Box<ModuleHeaderStmts<'t>>,
}

///
/// Type derived for non-terminal ModuleStmtList0
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmtList0<'t> {
    pub linkage_stmts: Box<LinkageStmts<'t>>,
}

///
/// Type derived for non-terminal ModuleStmtList1
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmtList1<'t> {
    pub meta_stmts: Box<MetaStmts<'t>>,
}

///
/// Type derived for non-terminal ModuleStmtList2
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmtList2<'t> {
    pub revision_stmt: Box<RevisionStmt<'t>>,
}

///
/// Type derived for non-terminal ModuleStmtList3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ModuleStmtList3<'t> {
    pub body_stmts: Box<BodyStmts<'t>>,
}

///
/// Type derived for non-terminal MustStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
    pub must_stmt_suffix: Box<MustStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal MustStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MustStmtList<'t> {
    pub must_stmt_list_group: Box<MustStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal MustStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum MustStmtListGroup<'t> {
    ErrorMessage(MustStmtListGroupErrorMessage<'t>),
    DescriptionStmt(MustStmtListGroupDescriptionStmt<'t>),
}

///
/// Type derived for non-terminal MustStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum MustStmtSuffix<'t> {
    Semicolon(MustStmtSuffixSemicolon),
    LBraceMustStmtListRBrace(MustStmtSuffixLBraceMustStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal NamespaceStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NamespaceStmt<'t> {
    pub uri_str: Box<UriStr<'t>>,
}

///
/// Type derived for non-terminal NonAscii
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NonAscii<'t> {
    pub non_ascii: Token<'t>, /* [\n\r\u{80}-\u{D7FF}\u{E000}-\u{10FFFF}] */
}

///
/// Type derived for non-terminal NotificationStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub notification_stmt_list: Vec<NotificationStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for non-terminal NotificationStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NotificationStmtList<'t> {
    pub notification_stmt_list_group: Box<NotificationStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal NotificationStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum NotificationStmtListGroup<'t> {
    IfFeatureStmt(NotificationStmtListGroupIfFeatureStmt<'t>),
    MustStmt(NotificationStmtListGroupMustStmt<'t>),
    StatusStmt(NotificationStmtListGroupStatusStmt<'t>),
    DescriptionStmt(NotificationStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(NotificationStmtListGroupReferenceStmt<'t>),
    TypedefStmt(NotificationStmtListGroupTypedefStmt<'t>),
    GroupingStmt(NotificationStmtListGroupGroupingStmt<'t>),
    DataDefStmt(NotificationStmtListGroupDataDefStmt<'t>),
}

///
/// Type derived for non-terminal OrderedByArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OrderedByArg<'t> {
    pub ordered_by_arg: Token<'t>, /* user|system */
}

///
/// Type derived for non-terminal OrderedByArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum OrderedByArgStr<'t> {
    OrderedByArg(OrderedByArgStrOrderedByArg<'t>),
    DoubleQuotationOrderedByArgDoubleQuotation(
        OrderedByArgStrDoubleQuotationOrderedByArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal OrderedByStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OrderedByStmt<'t> {
    pub ordered_by_arg_str: Box<OrderedByArgStr<'t>>,
}

///
/// Type derived for non-terminal OrganizationStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OrganizationStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal OutputStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OutputStmt<'t> {
    pub output: Token<'t>, /* output */
    pub output_stmt_list: Vec<OutputStmtList<'t>>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for non-terminal OutputStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct OutputStmtList<'t> {
    pub data_def_stmt: Box<DataDefStmt<'t>>,
}

///
/// Type derived for non-terminal PathStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PathStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
}

///
/// Type derived for non-terminal PatternStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PatternStmt<'t> {
    pub pattern: Token<'t>, /* pattern */
    pub ystring: Box<Ystring<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal PositionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PositionStmt<'t> {
    pub integer_value_str: Box<IntegerValueStr<'t>>,
}

///
/// Type derived for non-terminal PrefixStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PrefixStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
}

///
/// Type derived for non-terminal PresenceStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PresenceStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
}

///
/// Type derived for non-terminal RangeArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeArg<'t> {
    pub range_part: Box<RangePart<'t>>,
    pub range_arg_opt: Option<RangeArgOpt<'t>>,
}

///
/// Type derived for non-terminal RangeArgOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeArgOpt<'t> {
    pub or: Token<'t>, /* | */
    pub range_arg: Box<RangeArg<'t>>,
}

///
/// Type derived for non-terminal RangeArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RangeArgStr<'t> {
    RangeArg(RangeArgStrRangeArg<'t>),
    DoubleQuotationRangeArgDoubleQuotation(RangeArgStrDoubleQuotationRangeArgDoubleQuotation<'t>),
}

///
/// Type derived for non-terminal RangeBoundary
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RangeBoundary<'t> {
    Min(RangeBoundaryMin<'t>),
    Max(RangeBoundaryMax<'t>),
    MinusQuestLBracket0Minus9RBracketPlus(RangeBoundaryMinusQuestLBracket0Minus9RBracketPlus<'t>),
}

///
/// Type derived for non-terminal RangePart
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangePart<'t> {
    pub range_boundary: Box<RangeBoundary<'t>>,
    pub range_part_opt: Option<RangePartOpt<'t>>,
}

///
/// Type derived for non-terminal RangePartOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangePartOpt<'t> {
    pub dot_dot: Token<'t>, /* .. */
    pub range_boundary: Box<RangeBoundary<'t>>,
}

///
/// Type derived for non-terminal RangeStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RangeStmt<'t> {
    pub range_arg_str: Box<RangeArgStr<'t>>,
}

///
/// Type derived for non-terminal ReferenceStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ReferenceStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
}

///
/// Type derived for non-terminal RefineArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineArg<'t> {
    pub descendant_schema_nodeid: Box<DescendantSchemaNodeid<'t>>,
}

///
/// Type derived for non-terminal RefineArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RefineArgStr<'t> {
    RefineArg(RefineArgStrRefineArg<'t>),
    DoubleQuotationRefineArgDoubleQuotation(
        RefineArgStrDoubleQuotationRefineArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal RefineStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmt<'t> {
    pub refine_arg_str: Box<RefineArgStr<'t>>,
    pub refine_stmt_suffix: Box<RefineStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal RefineStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RefineStmtList<'t> {
    pub refine_stmt_list_group: Box<RefineStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal RefineStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RefineStmtListGroup<'t> {
    IfFeatureStmt(RefineStmtListGroupIfFeatureStmt<'t>),
    MustStmt(RefineStmtListGroupMustStmt<'t>),
    PresenceStmt(RefineStmtListGroupPresenceStmt<'t>),
    DefaultStmt(RefineStmtListGroupDefaultStmt<'t>),
    ConfigStmt(RefineStmtListGroupConfigStmt<'t>),
    MandatoryStmt(RefineStmtListGroupMandatoryStmt<'t>),
    MinElementsStmt(RefineStmtListGroupMinElementsStmt<'t>),
    MaxElementsStmt(RefineStmtListGroupMaxElementsStmt<'t>),
    DescriptionStmt(RefineStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(RefineStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal RefineStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RefineStmtSuffix<'t> {
    Semicolon(RefineStmtSuffixSemicolon),
    LBraceRefineStmtListRBrace(RefineStmtSuffixLBraceRefineStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal RequireInstanceArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RequireInstanceArgStr<'t> {
    MandatoryArg(RequireInstanceArgStrMandatoryArg<'t>),
    DoubleQuotationMandatoryArgDoubleQuotation(
        RequireInstanceArgStrDoubleQuotationMandatoryArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal RequireInstanceStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RequireInstanceStmt<'t> {
    pub require_instance_arg_str: Box<RequireInstanceArgStr<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal RevisionDateStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RevisionDateStmt<'t> {
    pub date_arg_str: Box<DateArgStr<'t>>,
}

///
/// Type derived for non-terminal RevisionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RevisionStmt<'t> {
    pub date_arg_str: Box<DateArgStr<'t>>,
    pub revision_stmt_list: Vec<RevisionStmtList<'t>>,
}

///
/// Type derived for non-terminal RevisionStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RevisionStmtList<'t> {
    pub revision_stmt_list_group: Box<RevisionStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal RevisionStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RevisionStmtListGroup<'t> {
    DescriptionStmt(RevisionStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(RevisionStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal RpcStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub rpc_stmt_suffix: Box<RpcStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal RpcStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RpcStmtList<'t> {
    pub rpc_stmt_list_group: Box<RpcStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal RpcStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RpcStmtListGroup<'t> {
    IfFeatureStmt(RpcStmtListGroupIfFeatureStmt<'t>),
    StatusStmt(RpcStmtListGroupStatusStmt<'t>),
    DescriptionStmt(RpcStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(RpcStmtListGroupReferenceStmt<'t>),
    TypedefStmt(RpcStmtListGroupTypedefStmt<'t>),
    GroupingStmt(RpcStmtListGroupGroupingStmt<'t>),
    InputStmt(RpcStmtListGroupInputStmt<'t>),
    OutputStmt(RpcStmtListGroupOutputStmt<'t>),
}

///
/// Type derived for non-terminal RpcStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RpcStmtSuffix<'t> {
    Semicolon(RpcStmtSuffixSemicolon<'t>),
    LBraceRpcStmtListRBrace(RpcStmtSuffixLBraceRpcStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal SQChar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum SQChar<'t> {
    SQUnescaped(SQCharSQUnescaped<'t>),
    SQEscaped(SQCharSQEscaped<'t>),
}

///
/// Type derived for non-terminal SQEscapeSeqChar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQEscapeSeqChar<'t> {
    pub s_q_escape_seq_char: Token<'t>, /* . */
}

///
/// Type derived for non-terminal SQEscaped
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQEscaped<'t> {
    pub escape: Box<Escape<'t>>,
    pub s_q_escape_seq_char: Box<SQEscapeSeqChar<'t>>,
}

///
/// Type derived for non-terminal SQNoEscape
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQNoEscape<'t> {
    pub s_q_no_escape: Token<'t>, /* [ \t\u{21}-\u{26}\u{28}-\u{5B}\u{5D}-\u{7E}]+ */
}

///
/// Type derived for non-terminal SQString
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQString<'t> {
    pub single_quotation: Box<SingleQuotation<'t>>,
    pub s_q_string_list: Vec<SQStringList<'t>>,
    pub single_quotation0: Box<SingleQuotation<'t>>,
}

///
/// Type derived for non-terminal SQStringList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SQStringList<'t> {
    pub s_q_char: Box<SQChar<'t>>,
}

///
/// Type derived for non-terminal SQUnescaped
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum SQUnescaped<'t> {
    SQNoEscape(SQUnescapedSQNoEscape<'t>),
    NonAscii(SQUnescapedNonAscii<'t>),
}

///
/// Type derived for non-terminal Semicolon
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Semicolon<'t> {
    pub semicolon: Token<'t>, /* ; */
}

///
/// Type derived for non-terminal ShortCaseStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ShortCaseStmt<'t> {
    ChoiceStmt(ShortCaseStmtChoiceStmt<'t>),
    ContainerStmt(ShortCaseStmtContainerStmt<'t>),
    LeafStmt(ShortCaseStmtLeafStmt<'t>),
    LeafListStmt(ShortCaseStmtLeafListStmt<'t>),
    ListStmt(ShortCaseStmtListStmt<'t>),
    AnydataStmt(ShortCaseStmtAnydataStmt<'t>),
    AnyxmlStmt(ShortCaseStmtAnyxmlStmt<'t>),
}

///
/// Type derived for non-terminal SingleQuotation
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SingleQuotation<'t> {
    pub single_quotation: Token<'t>, /* \u{27} */
}

///
/// Type derived for non-terminal StatusArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StatusArg<'t> {
    pub status_arg: Token<'t>, /* current|obsolete|deprecated */
}

///
/// Type derived for non-terminal StatusArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum StatusArgStr<'t> {
    StatusArg(StatusArgStrStatusArg<'t>),
    DoubleQuotationStatusArgDoubleQuotation(
        StatusArgStrDoubleQuotationStatusArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal StatusStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StatusStmt<'t> {
    pub status_arg_str: Box<StatusArgStr<'t>>,
}

///
/// Type derived for non-terminal StringRestrictions
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum StringRestrictions<'t> {
    LengthStmt(StringRestrictionsLengthStmt<'t>),
    PatternStmt(StringRestrictionsPatternStmt<'t>),
}

///
/// Type derived for non-terminal SubmoduleHeaderStmts
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum SubmoduleHeaderStmts<'t> {
    YangVersionStmt(SubmoduleHeaderStmtsYangVersionStmt<'t>),
    BelongsToStmt(SubmoduleHeaderStmtsBelongsToStmt<'t>),
}

///
/// Type derived for non-terminal SubmoduleStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub submodule_stmt_list: Vec<SubmoduleStmtList<'t>>,
    pub submodule_stmt_list0: Vec<SubmoduleStmtList0<'t>>,
    pub submodule_stmt_list1: Vec<SubmoduleStmtList1<'t>>,
    pub submodule_stmt_list2: Vec<SubmoduleStmtList2<'t>>,
    pub submodule_stmt_list3: Vec<SubmoduleStmtList3<'t>>,
}

///
/// Type derived for non-terminal SubmoduleStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmtList<'t> {
    pub submodule_header_stmts: Box<SubmoduleHeaderStmts<'t>>,
}

///
/// Type derived for non-terminal SubmoduleStmtList0
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmtList0<'t> {
    pub linkage_stmts: Box<LinkageStmts<'t>>,
}

///
/// Type derived for non-terminal SubmoduleStmtList1
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmtList1<'t> {
    pub meta_stmts: Box<MetaStmts<'t>>,
}

///
/// Type derived for non-terminal SubmoduleStmtList2
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmtList2<'t> {
    pub revision_stmt: Box<RevisionStmt<'t>>,
}

///
/// Type derived for non-terminal SubmoduleStmtList3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SubmoduleStmtList3<'t> {
    pub body_stmts: Box<BodyStmts<'t>>,
}

///
/// Type derived for non-terminal TypeStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmt<'t> {
    pub identifier_ref_arg_str: Box<IdentifierRefArgStr<'t>>,
    pub type_stmt_suffix: Box<TypeStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal TypeStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypeStmtList<'t> {
    pub type_stmt_list_group: Box<TypeStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal TypeStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TypeStmtListGroup<'t> {
    FractionDigitsStmt(TypeStmtListGroupFractionDigitsStmt<'t>),
    EnumStmt(TypeStmtListGroupEnumStmt<'t>),
    BaseStmt(TypeStmtListGroupBaseStmt<'t>),
    LeafrefSpecification(TypeStmtListGroupLeafrefSpecification<'t>),
    StringRestrictions(TypeStmtListGroupStringRestrictions<'t>),
    RangeStmt(TypeStmtListGroupRangeStmt<'t>),
    BitStmt(TypeStmtListGroupBitStmt<'t>),
    TypeStmt(TypeStmtListGroupTypeStmt<'t>),
}

///
/// Type derived for non-terminal TypeStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TypeStmtSuffix<'t> {
    Semicolon(TypeStmtSuffixSemicolon),
    LBraceTypeStmtListRBrace(TypeStmtSuffixLBraceTypeStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal TypedefStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmt<'t> {
    pub identifier_arg_str: Box<IdentifierArgStr<'t>>,
    pub typedef_stmt_list: Vec<TypedefStmtList<'t>>,
}

///
/// Type derived for non-terminal TypedefStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TypedefStmtList<'t> {
    pub typedef_stmt_list_group: Box<TypedefStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal TypedefStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TypedefStmtListGroup<'t> {
    TypeStmt(TypedefStmtListGroupTypeStmt<'t>),
    UnitsStmt(TypedefStmtListGroupUnitsStmt<'t>),
    DefaultStmt(TypedefStmtListGroupDefaultStmt<'t>),
    StatusStmt(TypedefStmtListGroupStatusStmt<'t>),
    DescriptionStmt(TypedefStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(TypedefStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal UnitsStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnitsStmt<'t> {
    pub units: Token<'t>, /* units */
    pub ystring: Box<Ystring<'t>>,
    pub semicolon: Box<Semicolon<'t>>,
}

///
/// Type derived for non-terminal UnknownStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmt<'t> {
    pub identifier_ref: Box<IdentifierRef<'t>>,
    pub ystring: Box<Ystring<'t>>,
    pub unknown_stmt_suffix: Box<UnknownStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal UnknownStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UnknownStmtList<'t> {
    pub unknown_stmt_list_group: Box<UnknownStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal UnknownStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum UnknownStmtListGroup<'t> {
    TypeStmt(UnknownStmtListGroupTypeStmt<'t>),
    DescriptionStmt(UnknownStmtListGroupDescriptionStmt<'t>),
}

///
/// Type derived for non-terminal UnknownStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum UnknownStmtSuffix<'t> {
    Semicolon(UnknownStmtSuffixSemicolon),
    LBraceUnknownStmtListRBrace(UnknownStmtSuffixLBraceUnknownStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal UriArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UriArg<'t> {
    pub uri_arg: Token<'t>, /* urn:[a-zA-Z0-9\-\.:]+ */
}

///
/// Type derived for non-terminal UriStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum UriStr<'t> {
    UriArg(UriStrUriArg<'t>),
    DoubleQuotationUriArgDoubleQuotation(UriStrDoubleQuotationUriArgDoubleQuotation<'t>),
}

///
/// Type derived for non-terminal UsesStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmt<'t> {
    pub identifier_ref_arg_str: Box<IdentifierRefArgStr<'t>>,
    pub uses_stmt_suffix: Box<UsesStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal UsesStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UsesStmtList<'t> {
    pub uses_stmt_list_group: Box<UsesStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal UsesStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum UsesStmtListGroup<'t> {
    WhenStmt(UsesStmtListGroupWhenStmt<'t>),
    IfFeatureStmt(UsesStmtListGroupIfFeatureStmt<'t>),
    StatusStmt(UsesStmtListGroupStatusStmt<'t>),
    DescriptionStmt(UsesStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(UsesStmtListGroupReferenceStmt<'t>),
    RefineStmt(UsesStmtListGroupRefineStmt<'t>),
    AugmentStmt(UsesStmtListGroupAugmentStmt<'t>),
}

///
/// Type derived for non-terminal UsesStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum UsesStmtSuffix<'t> {
    Semicolon(UsesStmtSuffixSemicolon),
    LBraceUsesStmtListRBrace(UsesStmtSuffixLBraceUsesStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal ValueStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueStmt<'t> {
    pub integer_value_str: Box<IntegerValueStr<'t>>,
}

///
/// Type derived for non-terminal WhenStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmt<'t> {
    pub ystring: Box<Ystring<'t>>,
    pub when_stmt_suffix: Box<WhenStmtSuffix<'t>>,
}

///
/// Type derived for non-terminal WhenStmtList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct WhenStmtList<'t> {
    pub when_stmt_list_group: Box<WhenStmtListGroup<'t>>,
}

///
/// Type derived for non-terminal WhenStmtListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum WhenStmtListGroup<'t> {
    DescriptionStmt(WhenStmtListGroupDescriptionStmt<'t>),
    ReferenceStmt(WhenStmtListGroupReferenceStmt<'t>),
}

///
/// Type derived for non-terminal WhenStmtSuffix
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum WhenStmtSuffix<'t> {
    Semicolon(WhenStmtSuffixSemicolon),
    LBraceWhenStmtListRBrace(WhenStmtSuffixLBraceWhenStmtListRBrace<'t>),
}

///
/// Type derived for non-terminal Yang
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Yang<'t> {
    ModuleStmt(YangModuleStmt<'t>),
    SubmoduleStmt(YangSubmoduleStmt<'t>),
}

///
/// Type derived for non-terminal YangVersionArg
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangVersionArg<'t> {
    pub yang_version_arg: Token<'t>, /* 1.1|1 */
}

///
/// Type derived for non-terminal YangVersionArgStr
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum YangVersionArgStr<'t> {
    YangVersionArg(YangVersionArgStrYangVersionArg<'t>),
    DoubleQuotationYangVersionArgDoubleQuotation(
        YangVersionArgStrDoubleQuotationYangVersionArgDoubleQuotation<'t>,
    ),
}

///
/// Type derived for non-terminal YangVersionStmt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YangVersionStmt<'t> {
    pub yang_version_arg_str: Box<YangVersionArgStr<'t>>,
}

///
/// Type derived for non-terminal Ystring
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Ystring<'t> {
    BasicStringYstringOpt(YstringBasicStringYstringOpt<'t>),
    Identifier(YstringIdentifier<'t>),
}

///
/// Type derived for non-terminal YstringOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct YstringOpt<'t> {
    pub plus: Token<'t>, /* + */
    pub ystring: Box<Ystring<'t>>,
}

// -------------------------------------------------------------------------------------------------

///
/// Deduced ASTType of expanded grammar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ASTType<'t> {
    AbsoluteSchemaNodeid(AbsoluteSchemaNodeid<'t>),
    ActionStmt(ActionStmt<'t>),
    ActionStmtList(Vec<ActionStmtList<'t>>),
    ActionStmtListGroup(ActionStmtListGroup<'t>),
    ActionStmtSuffix(ActionStmtSuffix<'t>),
    AnydataStmt(AnydataStmt<'t>),
    AnydataStmtList(Vec<AnydataStmtList<'t>>),
    AnydataStmtListGroup(AnydataStmtListGroup<'t>),
    AnydataStmtSuffix(AnydataStmtSuffix<'t>),
    AnyxmlStmt(AnyxmlStmt<'t>),
    AnyxmlStmtList(Vec<AnyxmlStmtList<'t>>),
    AnyxmlStmtListGroup(AnyxmlStmtListGroup<'t>),
    AnyxmlStmtSuffix(AnyxmlStmtSuffix<'t>),
    ArgumentStmt(ArgumentStmt<'t>),
    AsciiNoBrace(AsciiNoBrace<'t>),
    AsciiNoSemicolon(AsciiNoSemicolon<'t>),
    AugmentArgStr(AugmentArgStr<'t>),
    AugmentStmt(AugmentStmt<'t>),
    AugmentStmtList(Vec<AugmentStmtList<'t>>),
    AugmentStmtListGroup(AugmentStmtListGroup<'t>),
    BaseStmt(BaseStmt<'t>),
    BasicString(BasicString<'t>),
    BelongsToStmt(BelongsToStmt<'t>),
    BitStmt(BitStmt<'t>),
    BitStmtList(Vec<BitStmtList<'t>>),
    BitStmtListGroup(BitStmtListGroup<'t>),
    BitStmtSuffix(BitStmtSuffix<'t>),
    BodyStmts(BodyStmts<'t>),
    CaseStmt(CaseStmt<'t>),
    CaseStmtList(Vec<CaseStmtList<'t>>),
    CaseStmtListGroup(CaseStmtListGroup<'t>),
    CaseStmtSuffix(CaseStmtSuffix<'t>),
    ChoiceStmt(ChoiceStmt<'t>),
    ChoiceStmtList(Vec<ChoiceStmtList<'t>>),
    ChoiceStmtListGroup(ChoiceStmtListGroup<'t>),
    ChoiceStmtSuffix(ChoiceStmtSuffix<'t>),
    ConfigStmt(ConfigStmt<'t>),
    ContactStmt(ContactStmt<'t>),
    ContainerStmt(ContainerStmt<'t>),
    ContainerStmtList(Vec<ContainerStmtList<'t>>),
    ContainerStmtListGroup(ContainerStmtListGroup<'t>),
    ContainerStmtSuffix(ContainerStmtSuffix<'t>),
    DQChar(DQChar<'t>),
    DQEscapeSeqChar(DQEscapeSeqChar<'t>),
    DQEscaped(DQEscaped<'t>),
    DQNoEscape(DQNoEscape<'t>),
    DQString(DQString<'t>),
    DQStringList(Vec<DQStringList<'t>>),
    DQUnescaped(DQUnescaped<'t>),
    DataDefStmt(DataDefStmt<'t>),
    DateArg(DateArg<'t>),
    DateArgStr(DateArgStr<'t>),
    DefaultStmt(DefaultStmt<'t>),
    DefaultStmtSuffix(DefaultStmtSuffix<'t>),
    DescendantSchemaNodeid(DescendantSchemaNodeid<'t>),
    DescriptionStmt(DescriptionStmt<'t>),
    DeviationStmt(DeviationStmt<'t>),
    DoubleQuotation(DoubleQuotation<'t>),
    EnumArgStr(EnumArgStr<'t>),
    EnumStmt(EnumStmt<'t>),
    EnumStmtList(Vec<EnumStmtList<'t>>),
    EnumStmtListGroup(EnumStmtListGroup<'t>),
    EnumStmtSuffix(EnumStmtSuffix<'t>),
    ErrorMessage(ErrorMessage<'t>),
    EscN(EscN<'t>),
    EscT(EscT<'t>),
    Escape(Escape<'t>),
    ExtensionStmt(ExtensionStmt<'t>),
    ExtensionStmtList(Vec<ExtensionStmtList<'t>>),
    ExtensionStmtListGroup(ExtensionStmtListGroup<'t>),
    ExtensionStmtSuffix(ExtensionStmtSuffix<'t>),
    FeatureStmt(FeatureStmt<'t>),
    FeatureStmtList(Vec<FeatureStmtList<'t>>),
    FeatureStmtListGroup(FeatureStmtListGroup<'t>),
    FeatureStmtSuffix(FeatureStmtSuffix<'t>),
    FractionDigitsArg(FractionDigitsArg<'t>),
    FractionDigitsStmt(FractionDigitsStmt<'t>),
    GroupingStmt(GroupingStmt<'t>),
    GroupingStmtList(Vec<GroupingStmtList<'t>>),
    GroupingStmtListGroup(GroupingStmtListGroup<'t>),
    Identifier(Identifier<'t>),
    IdentifierArgStr(IdentifierArgStr<'t>),
    IdentifierRef(IdentifierRef<'t>),
    IdentifierRefArgStr(IdentifierRefArgStr<'t>),
    IdentifierRefOpt(Option<IdentifierRefOpt<'t>>),
    IdentityStmt(IdentityStmt<'t>),
    IdentityStmtList(Vec<IdentityStmtList<'t>>),
    IdentityStmtListGroup(IdentityStmtListGroup<'t>),
    IfFeatureExpr(IfFeatureExpr<'t>),
    IfFeatureExprOpt(Option<IfFeatureExprOpt<'t>>),
    IfFeatureExprStr(IfFeatureExprStr<'t>),
    IfFeatureFactor(IfFeatureFactor<'t>),
    IfFeatureStmt(IfFeatureStmt<'t>),
    IfFeatureTerm(IfFeatureTerm<'t>),
    IfFeatureTermOpt(Option<IfFeatureTermOpt<'t>>),
    ImportStmt(ImportStmt<'t>),
    ImportStmtList(Vec<ImportStmtList<'t>>),
    ImportStmtListGroup(ImportStmtListGroup<'t>),
    IncludeStmt(IncludeStmt<'t>),
    IncludeStmtList(Vec<IncludeStmtList<'t>>),
    IncludeStmtListGroup(IncludeStmtListGroup<'t>),
    IncludeStmtSuffix(IncludeStmtSuffix<'t>),
    InputStmt(InputStmt<'t>),
    InputStmtList(Vec<InputStmtList<'t>>),
    IntegerValue(IntegerValue<'t>),
    IntegerValueStr(IntegerValueStr<'t>),
    KeyArg(KeyArg<'t>),
    KeyArgOpt(Option<KeyArgOpt<'t>>),
    KeyArgStr(KeyArgStr<'t>),
    KeyStmt(KeyStmt<'t>),
    KwAction(KwAction<'t>),
    KwAnydata(KwAnydata<'t>),
    KwAnyxml(KwAnyxml<'t>),
    KwArgument(KwArgument<'t>),
    KwBase(KwBase<'t>),
    KwBelongsTo(KwBelongsTo<'t>),
    KwBit(KwBit<'t>),
    KwCase(KwCase<'t>),
    KwChoice(KwChoice<'t>),
    KwConfig(KwConfig<'t>),
    KwContainer(KwContainer<'t>),
    KwDefault(KwDefault<'t>),
    KwDeviation(KwDeviation<'t>),
    KwEnum(KwEnum<'t>),
    KwExtension(KwExtension<'t>),
    KwFeature(KwFeature<'t>),
    KwFractionDigits(KwFractionDigits<'t>),
    KwGrouping(KwGrouping<'t>),
    KwIdentity(KwIdentity<'t>),
    KwIfFeature(KwIfFeature<'t>),
    KwImport(KwImport<'t>),
    KwInclude(KwInclude<'t>),
    KwKey(KwKey<'t>),
    KwLeaf(KwLeaf<'t>),
    KwLeafList(KwLeafList<'t>),
    KwLength(KwLength<'t>),
    KwList(KwList<'t>),
    KwMandatory(KwMandatory<'t>),
    KwModule(KwModule<'t>),
    KwNamespace(KwNamespace<'t>),
    KwNotification(KwNotification<'t>),
    KwOrderedBy(KwOrderedBy<'t>),
    KwPosition(KwPosition<'t>),
    KwPrefix(KwPrefix<'t>),
    KwRange(KwRange<'t>),
    KwRefine(KwRefine<'t>),
    KwRequireInstance(KwRequireInstance<'t>),
    KwRevision(KwRevision<'t>),
    KwRevisionDate(KwRevisionDate<'t>),
    KwRpc(KwRpc<'t>),
    KwStatus(KwStatus<'t>),
    KwSubmodule(KwSubmodule<'t>),
    KwType(KwType<'t>),
    KwTypedef(KwTypedef<'t>),
    KwUses(KwUses<'t>),
    KwValue(KwValue<'t>),
    KwYangVersion(KwYangVersion<'t>),
    LBrace(LBrace<'t>),
    LeafListStmt(LeafListStmt<'t>),
    LeafListStmtList(Vec<LeafListStmtList<'t>>),
    LeafListStmtListGroup(LeafListStmtListGroup<'t>),
    LeafStmt(LeafStmt<'t>),
    LeafStmtList(Vec<LeafStmtList<'t>>),
    LeafStmtListGroup(LeafStmtListGroup<'t>),
    LeafrefSpecification(LeafrefSpecification<'t>),
    LengthStmt(LengthStmt<'t>),
    LinkageStmts(LinkageStmts<'t>),
    ListStmt(ListStmt<'t>),
    ListStmtList(Vec<ListStmtList<'t>>),
    ListStmtListGroup(ListStmtListGroup<'t>),
    MandatoryArg(MandatoryArg<'t>),
    MandatoryArgStr(MandatoryArgStr<'t>),
    MandatoryStmt(MandatoryStmt<'t>),
    MaxElementsStmt(MaxElementsStmt<'t>),
    MetaStmts(MetaStmts<'t>),
    MinElementsStmt(MinElementsStmt<'t>),
    ModuleHeaderStmts(ModuleHeaderStmts<'t>),
    ModuleStmt(ModuleStmt<'t>),
    ModuleStmtList(Vec<ModuleStmtList<'t>>),
    ModuleStmtList0(Vec<ModuleStmtList0<'t>>),
    ModuleStmtList1(Vec<ModuleStmtList1<'t>>),
    ModuleStmtList2(Vec<ModuleStmtList2<'t>>),
    ModuleStmtList3(Vec<ModuleStmtList3<'t>>),
    MustStmt(MustStmt<'t>),
    MustStmtList(Vec<MustStmtList<'t>>),
    MustStmtListGroup(MustStmtListGroup<'t>),
    MustStmtSuffix(MustStmtSuffix<'t>),
    NamespaceStmt(NamespaceStmt<'t>),
    NonAscii(NonAscii<'t>),
    NotificationStmt(NotificationStmt<'t>),
    NotificationStmtList(Vec<NotificationStmtList<'t>>),
    NotificationStmtListGroup(NotificationStmtListGroup<'t>),
    OrderedByArg(OrderedByArg<'t>),
    OrderedByArgStr(OrderedByArgStr<'t>),
    OrderedByStmt(OrderedByStmt<'t>),
    OrganizationStmt(OrganizationStmt<'t>),
    OutputStmt(OutputStmt<'t>),
    OutputStmtList(Vec<OutputStmtList<'t>>),
    PathStmt(PathStmt<'t>),
    PatternStmt(PatternStmt<'t>),
    PositionStmt(PositionStmt<'t>),
    PrefixStmt(PrefixStmt<'t>),
    PresenceStmt(PresenceStmt<'t>),
    RangeArg(RangeArg<'t>),
    RangeArgOpt(Option<RangeArgOpt<'t>>),
    RangeArgStr(RangeArgStr<'t>),
    RangeBoundary(RangeBoundary<'t>),
    RangePart(RangePart<'t>),
    RangePartOpt(Option<RangePartOpt<'t>>),
    RangeStmt(RangeStmt<'t>),
    ReferenceStmt(ReferenceStmt<'t>),
    RefineArg(RefineArg<'t>),
    RefineArgStr(RefineArgStr<'t>),
    RefineStmt(RefineStmt<'t>),
    RefineStmtList(Vec<RefineStmtList<'t>>),
    RefineStmtListGroup(RefineStmtListGroup<'t>),
    RefineStmtSuffix(RefineStmtSuffix<'t>),
    RequireInstanceArgStr(RequireInstanceArgStr<'t>),
    RequireInstanceStmt(RequireInstanceStmt<'t>),
    RevisionDateStmt(RevisionDateStmt<'t>),
    RevisionStmt(RevisionStmt<'t>),
    RevisionStmtList(Vec<RevisionStmtList<'t>>),
    RevisionStmtListGroup(RevisionStmtListGroup<'t>),
    RpcStmt(RpcStmt<'t>),
    RpcStmtList(Vec<RpcStmtList<'t>>),
    RpcStmtListGroup(RpcStmtListGroup<'t>),
    RpcStmtSuffix(RpcStmtSuffix<'t>),
    SQChar(SQChar<'t>),
    SQEscapeSeqChar(SQEscapeSeqChar<'t>),
    SQEscaped(SQEscaped<'t>),
    SQNoEscape(SQNoEscape<'t>),
    SQString(SQString<'t>),
    SQStringList(Vec<SQStringList<'t>>),
    SQUnescaped(SQUnescaped<'t>),
    Semicolon(Semicolon<'t>),
    ShortCaseStmt(ShortCaseStmt<'t>),
    SingleQuotation(SingleQuotation<'t>),
    StatusArg(StatusArg<'t>),
    StatusArgStr(StatusArgStr<'t>),
    StatusStmt(StatusStmt<'t>),
    StringRestrictions(StringRestrictions<'t>),
    SubmoduleHeaderStmts(SubmoduleHeaderStmts<'t>),
    SubmoduleStmt(SubmoduleStmt<'t>),
    SubmoduleStmtList(Vec<SubmoduleStmtList<'t>>),
    SubmoduleStmtList0(Vec<SubmoduleStmtList0<'t>>),
    SubmoduleStmtList1(Vec<SubmoduleStmtList1<'t>>),
    SubmoduleStmtList2(Vec<SubmoduleStmtList2<'t>>),
    SubmoduleStmtList3(Vec<SubmoduleStmtList3<'t>>),
    TypeStmt(TypeStmt<'t>),
    TypeStmtList(Vec<TypeStmtList<'t>>),
    TypeStmtListGroup(TypeStmtListGroup<'t>),
    TypeStmtSuffix(TypeStmtSuffix<'t>),
    TypedefStmt(TypedefStmt<'t>),
    TypedefStmtList(Vec<TypedefStmtList<'t>>),
    TypedefStmtListGroup(TypedefStmtListGroup<'t>),
    UnitsStmt(UnitsStmt<'t>),
    UnknownStmt(UnknownStmt<'t>),
    UnknownStmtList(Vec<UnknownStmtList<'t>>),
    UnknownStmtListGroup(UnknownStmtListGroup<'t>),
    UnknownStmtSuffix(UnknownStmtSuffix<'t>),
    UriArg(UriArg<'t>),
    UriStr(UriStr<'t>),
    UsesStmt(UsesStmt<'t>),
    UsesStmtList(Vec<UsesStmtList<'t>>),
    UsesStmtListGroup(UsesStmtListGroup<'t>),
    UsesStmtSuffix(UsesStmtSuffix<'t>),
    ValueStmt(ValueStmt<'t>),
    WhenStmt(WhenStmt<'t>),
    WhenStmtList(Vec<WhenStmtList<'t>>),
    WhenStmtListGroup(WhenStmtListGroup<'t>),
    WhenStmtSuffix(WhenStmtSuffix<'t>),
    Yang(Yang<'t>),
    YangVersionArg(YangVersionArg<'t>),
    YangVersionArgStr(YangVersionArgStr<'t>),
    YangVersionStmt(YangVersionStmt<'t>),
    Ystring(Ystring<'t>),
    YstringOpt(Option<YstringOpt<'t>>),
}

// -------------------------------------------------------------------------------------------------

/// Auto-implemented adapter grammar
///
/// The lifetime parameter `'t` refers to the lifetime of the scanned text.
/// The lifetime parameter `'u` refers to the lifetime of user grammar object.
///
#[allow(dead_code)]
pub struct YangGrammarAuto<'t, 'u>
where
    't: 'u,
{
    // Mutable reference of the actual user grammar to be able to call the semantic actions on it
    user_grammar: &'u mut dyn YangGrammarTrait<'t>,
    // Stack to construct the AST on it
    item_stack: Vec<ASTType<'t>>,
}

///
/// The `YangGrammarAuto` impl is automatically generated for the
/// given grammar.
///
impl<'t, 'u> YangGrammarAuto<'t, 'u> {
    pub fn new(user_grammar: &'u mut dyn YangGrammarTrait<'t>) -> Self {
        Self {
            user_grammar,
            item_stack: Vec::new(),
        }
    }

    #[allow(dead_code)]
    fn push(&mut self, item: ASTType<'t>, context: &str) {
        trace!("push    {context}: {item:?}");
        self.item_stack.push(item)
    }

    #[allow(dead_code)]
    fn pop(&mut self, context: &str) -> Option<ASTType<'t>> {
        let item = self.item_stack.pop();
        if let Some(ref item) = item {
            trace!("pop     {context}: {item:?}");
        }
        item
    }

    #[allow(dead_code)]
    // Use this function for debugging purposes:
    // trace!("{}", self.trace_item_stack(context));
    fn trace_item_stack(&self, context: &str) -> std::string::String {
        format!(
            "Item stack at {}:\n{}",
            context,
            self.item_stack
                .iter()
                .rev()
                .map(|s| format!("  {s:?}"))
                .collect::<Vec<std::string::String>>()
                .join("\n")
        )
    }

    /// Semantic action for production 0:
    ///
    /// `LBrace: <INITIAL, Keyword, Enum, Revision>'{';`
    ///
    #[parol_runtime::function_name::named]
    fn l_brace(&mut self, l_brace: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_brace = l_brace.token()?.clone();
        let l_brace_built = LBrace { l_brace };
        // Calling user action here
        self.user_grammar.l_brace(&l_brace_built)?;
        self.push(ASTType::LBrace(l_brace_built), context);
        Ok(())
    }

    /// Semantic action for production 1:
    ///
    /// `EscN: <Esc>"n";`
    ///
    #[parol_runtime::function_name::named]
    fn esc_n(&mut self, esc_n: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let esc_n = esc_n.token()?.clone();
        let esc_n_built = EscN { esc_n };
        // Calling user action here
        self.user_grammar.esc_n(&esc_n_built)?;
        self.push(ASTType::EscN(esc_n_built), context);
        Ok(())
    }

    /// Semantic action for production 2:
    ///
    /// `EscT: <Esc>"t";`
    ///
    #[parol_runtime::function_name::named]
    fn esc_t(&mut self, esc_t: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let esc_t = esc_t.token()?.clone();
        let esc_t_built = EscT { esc_t };
        // Calling user action here
        self.user_grammar.esc_t(&esc_t_built)?;
        self.push(ASTType::EscT(esc_t_built), context);
        Ok(())
    }

    /// Semantic action for production 3:
    ///
    /// `KwModule: 'module';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_module(&mut self, kw_module: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_module = kw_module.token()?.clone();
        let kw_module_built = KwModule { kw_module };
        // Calling user action here
        self.user_grammar.kw_module(&kw_module_built)?;
        self.push(ASTType::KwModule(kw_module_built), context);
        Ok(())
    }

    /// Semantic action for production 4:
    ///
    /// `KwSubmodule: 'submodule';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_submodule(&mut self, kw_submodule: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_submodule = kw_submodule.token()?.clone();
        let kw_submodule_built = KwSubmodule { kw_submodule };
        // Calling user action here
        self.user_grammar.kw_submodule(&kw_submodule_built)?;
        self.push(ASTType::KwSubmodule(kw_submodule_built), context);
        Ok(())
    }

    /// Semantic action for production 5:
    ///
    /// `KwRpc: 'rpc';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_rpc(&mut self, kw_rpc: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_rpc = kw_rpc.token()?.clone();
        let kw_rpc_built = KwRpc { kw_rpc };
        // Calling user action here
        self.user_grammar.kw_rpc(&kw_rpc_built)?;
        self.push(ASTType::KwRpc(kw_rpc_built), context);
        Ok(())
    }

    /// Semantic action for production 6:
    ///
    /// `KwExtension: 'extension';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_extension(&mut self, kw_extension: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_extension = kw_extension.token()?.clone();
        let kw_extension_built = KwExtension { kw_extension };
        // Calling user action here
        self.user_grammar.kw_extension(&kw_extension_built)?;
        self.push(ASTType::KwExtension(kw_extension_built), context);
        Ok(())
    }

    /// Semantic action for production 7:
    ///
    /// `KwArgument: 'argument';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_argument(&mut self, kw_argument: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_argument = kw_argument.token()?.clone();
        let kw_argument_built = KwArgument { kw_argument };
        // Calling user action here
        self.user_grammar.kw_argument(&kw_argument_built)?;
        self.push(ASTType::KwArgument(kw_argument_built), context);
        Ok(())
    }

    /// Semantic action for production 8:
    ///
    /// `KwFeature: 'feature';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_feature(&mut self, kw_feature: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_feature = kw_feature.token()?.clone();
        let kw_feature_built = KwFeature { kw_feature };
        // Calling user action here
        self.user_grammar.kw_feature(&kw_feature_built)?;
        self.push(ASTType::KwFeature(kw_feature_built), context);
        Ok(())
    }

    /// Semantic action for production 9:
    ///
    /// `KwTypedef: 'typedef';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_typedef(&mut self, kw_typedef: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_typedef = kw_typedef.token()?.clone();
        let kw_typedef_built = KwTypedef { kw_typedef };
        // Calling user action here
        self.user_grammar.kw_typedef(&kw_typedef_built)?;
        self.push(ASTType::KwTypedef(kw_typedef_built), context);
        Ok(())
    }

    /// Semantic action for production 10:
    ///
    /// `KwGrouping: 'grouping';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_grouping(&mut self, kw_grouping: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_grouping = kw_grouping.token()?.clone();
        let kw_grouping_built = KwGrouping { kw_grouping };
        // Calling user action here
        self.user_grammar.kw_grouping(&kw_grouping_built)?;
        self.push(ASTType::KwGrouping(kw_grouping_built), context);
        Ok(())
    }

    /// Semantic action for production 11:
    ///
    /// `KwIdentity: 'identity';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_identity(&mut self, kw_identity: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_identity = kw_identity.token()?.clone();
        let kw_identity_built = KwIdentity { kw_identity };
        // Calling user action here
        self.user_grammar.kw_identity(&kw_identity_built)?;
        self.push(ASTType::KwIdentity(kw_identity_built), context);
        Ok(())
    }

    /// Semantic action for production 12:
    ///
    /// `KwAnyxml: 'anyxml';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_anyxml(&mut self, kw_anyxml: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_anyxml = kw_anyxml.token()?.clone();
        let kw_anyxml_built = KwAnyxml { kw_anyxml };
        // Calling user action here
        self.user_grammar.kw_anyxml(&kw_anyxml_built)?;
        self.push(ASTType::KwAnyxml(kw_anyxml_built), context);
        Ok(())
    }

    /// Semantic action for production 13:
    ///
    /// `KwAnydata: 'anydata';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_anydata(&mut self, kw_anydata: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_anydata = kw_anydata.token()?.clone();
        let kw_anydata_built = KwAnydata { kw_anydata };
        // Calling user action here
        self.user_grammar.kw_anydata(&kw_anydata_built)?;
        self.push(ASTType::KwAnydata(kw_anydata_built), context);
        Ok(())
    }

    /// Semantic action for production 14:
    ///
    /// `KwCase: 'case';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_case(&mut self, kw_case: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_case = kw_case.token()?.clone();
        let kw_case_built = KwCase { kw_case };
        // Calling user action here
        self.user_grammar.kw_case(&kw_case_built)?;
        self.push(ASTType::KwCase(kw_case_built), context);
        Ok(())
    }

    /// Semantic action for production 15:
    ///
    /// `KwContainer: 'container';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_container(&mut self, kw_container: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_container = kw_container.token()?.clone();
        let kw_container_built = KwContainer { kw_container };
        // Calling user action here
        self.user_grammar.kw_container(&kw_container_built)?;
        self.push(ASTType::KwContainer(kw_container_built), context);
        Ok(())
    }

    /// Semantic action for production 16:
    ///
    /// `KwAction: 'action';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_action(&mut self, kw_action: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_action = kw_action.token()?.clone();
        let kw_action_built = KwAction { kw_action };
        // Calling user action here
        self.user_grammar.kw_action(&kw_action_built)?;
        self.push(ASTType::KwAction(kw_action_built), context);
        Ok(())
    }

    /// Semantic action for production 17:
    ///
    /// `KwNotification: 'notification';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_notification(&mut self, kw_notification: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_notification = kw_notification.token()?.clone();
        let kw_notification_built = KwNotification { kw_notification };
        // Calling user action here
        self.user_grammar.kw_notification(&kw_notification_built)?;
        self.push(ASTType::KwNotification(kw_notification_built), context);
        Ok(())
    }

    /// Semantic action for production 18:
    ///
    /// `KwLeafList: 'leaf-list';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_leaf_list(&mut self, kw_leaf_list: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_leaf_list = kw_leaf_list.token()?.clone();
        let kw_leaf_list_built = KwLeafList { kw_leaf_list };
        // Calling user action here
        self.user_grammar.kw_leaf_list(&kw_leaf_list_built)?;
        self.push(ASTType::KwLeafList(kw_leaf_list_built), context);
        Ok(())
    }

    /// Semantic action for production 19:
    ///
    /// `KwLeaf: 'leaf';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_leaf(&mut self, kw_leaf: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_leaf = kw_leaf.token()?.clone();
        let kw_leaf_built = KwLeaf { kw_leaf };
        // Calling user action here
        self.user_grammar.kw_leaf(&kw_leaf_built)?;
        self.push(ASTType::KwLeaf(kw_leaf_built), context);
        Ok(())
    }

    /// Semantic action for production 20:
    ///
    /// `KwList: 'list';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_list(&mut self, kw_list: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_list = kw_list.token()?.clone();
        let kw_list_built = KwList { kw_list };
        // Calling user action here
        self.user_grammar.kw_list(&kw_list_built)?;
        self.push(ASTType::KwList(kw_list_built), context);
        Ok(())
    }

    /// Semantic action for production 21:
    ///
    /// `KwBit: 'bit';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_bit(&mut self, kw_bit: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_bit = kw_bit.token()?.clone();
        let kw_bit_built = KwBit { kw_bit };
        // Calling user action here
        self.user_grammar.kw_bit(&kw_bit_built)?;
        self.push(ASTType::KwBit(kw_bit_built), context);
        Ok(())
    }

    /// Semantic action for production 22:
    ///
    /// `KwImport: 'import';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_import(&mut self, kw_import: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_import = kw_import.token()?.clone();
        let kw_import_built = KwImport { kw_import };
        // Calling user action here
        self.user_grammar.kw_import(&kw_import_built)?;
        self.push(ASTType::KwImport(kw_import_built), context);
        Ok(())
    }

    /// Semantic action for production 23:
    ///
    /// `KwInclude: 'include';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_include(&mut self, kw_include: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_include = kw_include.token()?.clone();
        let kw_include_built = KwInclude { kw_include };
        // Calling user action here
        self.user_grammar.kw_include(&kw_include_built)?;
        self.push(ASTType::KwInclude(kw_include_built), context);
        Ok(())
    }

    /// Semantic action for production 24:
    ///
    /// `KwPrefix: 'prefix';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_prefix(&mut self, kw_prefix: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_prefix = kw_prefix.token()?.clone();
        let kw_prefix_built = KwPrefix { kw_prefix };
        // Calling user action here
        self.user_grammar.kw_prefix(&kw_prefix_built)?;
        self.push(ASTType::KwPrefix(kw_prefix_built), context);
        Ok(())
    }

    /// Semantic action for production 25:
    ///
    /// `KwBelongsTo: 'belongs-to';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_belongs_to(&mut self, kw_belongs_to: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_belongs_to = kw_belongs_to.token()?.clone();
        let kw_belongs_to_built = KwBelongsTo { kw_belongs_to };
        // Calling user action here
        self.user_grammar.kw_belongs_to(&kw_belongs_to_built)?;
        self.push(ASTType::KwBelongsTo(kw_belongs_to_built), context);
        Ok(())
    }

    /// Semantic action for production 26:
    ///
    /// `KwBase: 'base';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_base(&mut self, kw_base: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_base = kw_base.token()?.clone();
        let kw_base_built = KwBase { kw_base };
        // Calling user action here
        self.user_grammar.kw_base(&kw_base_built)?;
        self.push(ASTType::KwBase(kw_base_built), context);
        Ok(())
    }

    /// Semantic action for production 27:
    ///
    /// `KwChoice: 'choice';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_choice(&mut self, kw_choice: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_choice = kw_choice.token()?.clone();
        let kw_choice_built = KwChoice { kw_choice };
        // Calling user action here
        self.user_grammar.kw_choice(&kw_choice_built)?;
        self.push(ASTType::KwChoice(kw_choice_built), context);
        Ok(())
    }

    /// Semantic action for production 28:
    ///
    /// `KwUses: 'uses';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_uses(&mut self, kw_uses: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_uses = kw_uses.token()?.clone();
        let kw_uses_built = KwUses { kw_uses };
        // Calling user action here
        self.user_grammar.kw_uses(&kw_uses_built)?;
        self.push(ASTType::KwUses(kw_uses_built), context);
        Ok(())
    }

    /// Semantic action for production 29:
    ///
    /// `KwType: 'type';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_type(&mut self, kw_type: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_type = kw_type.token()?.clone();
        let kw_type_built = KwType { kw_type };
        // Calling user action here
        self.user_grammar.kw_type(&kw_type_built)?;
        self.push(ASTType::KwType(kw_type_built), context);
        Ok(())
    }

    /// Semantic action for production 30:
    ///
    /// `KwRefine: 'refine';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_refine(&mut self, kw_refine: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_refine = kw_refine.token()?.clone();
        let kw_refine_built = KwRefine { kw_refine };
        // Calling user action here
        self.user_grammar.kw_refine(&kw_refine_built)?;
        self.push(ASTType::KwRefine(kw_refine_built), context);
        Ok(())
    }

    /// Semantic action for production 31:
    ///
    /// `KwKey: 'key';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_key(&mut self, kw_key: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_key = kw_key.token()?.clone();
        let kw_key_built = KwKey { kw_key };
        // Calling user action here
        self.user_grammar.kw_key(&kw_key_built)?;
        self.push(ASTType::KwKey(kw_key_built), context);
        Ok(())
    }

    /// Semantic action for production 32:
    ///
    /// `KwDeviation: 'deviation';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_deviation(&mut self, kw_deviation: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_deviation = kw_deviation.token()?.clone();
        let kw_deviation_built = KwDeviation { kw_deviation };
        // Calling user action here
        self.user_grammar.kw_deviation(&kw_deviation_built)?;
        self.push(ASTType::KwDeviation(kw_deviation_built), context);
        Ok(())
    }

    /// Semantic action for production 33:
    ///
    /// `KwYangVersion: 'yang-version';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_yang_version(&mut self, kw_yang_version: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_yang_version = kw_yang_version.token()?.clone();
        let kw_yang_version_built = KwYangVersion { kw_yang_version };
        // Calling user action here
        self.user_grammar.kw_yang_version(&kw_yang_version_built)?;
        self.push(ASTType::KwYangVersion(kw_yang_version_built), context);
        Ok(())
    }

    /// Semantic action for production 34:
    ///
    /// `KwStatus: 'status';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_status(&mut self, kw_status: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_status = kw_status.token()?.clone();
        let kw_status_built = KwStatus { kw_status };
        // Calling user action here
        self.user_grammar.kw_status(&kw_status_built)?;
        self.push(ASTType::KwStatus(kw_status_built), context);
        Ok(())
    }

    /// Semantic action for production 35:
    ///
    /// `KwIfFeature: 'if-feature';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_if_feature(&mut self, kw_if_feature: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_if_feature = kw_if_feature.token()?.clone();
        let kw_if_feature_built = KwIfFeature { kw_if_feature };
        // Calling user action here
        self.user_grammar.kw_if_feature(&kw_if_feature_built)?;
        self.push(ASTType::KwIfFeature(kw_if_feature_built), context);
        Ok(())
    }

    /// Semantic action for production 36:
    ///
    /// `KwMandatory: 'mandatory';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_mandatory(&mut self, kw_mandatory: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_mandatory = kw_mandatory.token()?.clone();
        let kw_mandatory_built = KwMandatory { kw_mandatory };
        // Calling user action here
        self.user_grammar.kw_mandatory(&kw_mandatory_built)?;
        self.push(ASTType::KwMandatory(kw_mandatory_built), context);
        Ok(())
    }

    /// Semantic action for production 37:
    ///
    /// `KwConfig: 'config';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_config(&mut self, kw_config: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_config = kw_config.token()?.clone();
        let kw_config_built = KwConfig { kw_config };
        // Calling user action here
        self.user_grammar.kw_config(&kw_config_built)?;
        self.push(ASTType::KwConfig(kw_config_built), context);
        Ok(())
    }

    /// Semantic action for production 38:
    ///
    /// `KwRequireInstance: 'require-instance';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_require_instance(&mut self, kw_require_instance: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_require_instance = kw_require_instance.token()?.clone();
        let kw_require_instance_built = KwRequireInstance {
            kw_require_instance,
        };
        // Calling user action here
        self.user_grammar
            .kw_require_instance(&kw_require_instance_built)?;
        self.push(
            ASTType::KwRequireInstance(kw_require_instance_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 39:
    ///
    /// `KwOrderedBy: 'ordered-by';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_ordered_by(&mut self, kw_ordered_by: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_ordered_by = kw_ordered_by.token()?.clone();
        let kw_ordered_by_built = KwOrderedBy { kw_ordered_by };
        // Calling user action here
        self.user_grammar.kw_ordered_by(&kw_ordered_by_built)?;
        self.push(ASTType::KwOrderedBy(kw_ordered_by_built), context);
        Ok(())
    }

    /// Semantic action for production 40:
    ///
    /// `KwDefault: 'default';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_default(&mut self, kw_default: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_default = kw_default.token()?.clone();
        let kw_default_built = KwDefault { kw_default };
        // Calling user action here
        self.user_grammar.kw_default(&kw_default_built)?;
        self.push(ASTType::KwDefault(kw_default_built), context);
        Ok(())
    }

    /// Semantic action for production 41:
    ///
    /// `KwFractionDigits: 'fraction-digits';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_fraction_digits(&mut self, kw_fraction_digits: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_fraction_digits = kw_fraction_digits.token()?.clone();
        let kw_fraction_digits_built = KwFractionDigits { kw_fraction_digits };
        // Calling user action here
        self.user_grammar
            .kw_fraction_digits(&kw_fraction_digits_built)?;
        self.push(ASTType::KwFractionDigits(kw_fraction_digits_built), context);
        Ok(())
    }

    /// Semantic action for production 42:
    ///
    /// `KwLength: 'length';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_length(&mut self, kw_length: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_length = kw_length.token()?.clone();
        let kw_length_built = KwLength { kw_length };
        // Calling user action here
        self.user_grammar.kw_length(&kw_length_built)?;
        self.push(ASTType::KwLength(kw_length_built), context);
        Ok(())
    }

    /// Semantic action for production 43:
    ///
    /// `KwRange: 'range';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_range(&mut self, kw_range: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_range = kw_range.token()?.clone();
        let kw_range_built = KwRange { kw_range };
        // Calling user action here
        self.user_grammar.kw_range(&kw_range_built)?;
        self.push(ASTType::KwRange(kw_range_built), context);
        Ok(())
    }

    /// Semantic action for production 44:
    ///
    /// `KwValue: 'value';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_value(&mut self, kw_value: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_value = kw_value.token()?.clone();
        let kw_value_built = KwValue { kw_value };
        // Calling user action here
        self.user_grammar.kw_value(&kw_value_built)?;
        self.push(ASTType::KwValue(kw_value_built), context);
        Ok(())
    }

    /// Semantic action for production 45:
    ///
    /// `KwPosition: 'position';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_position(&mut self, kw_position: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_position = kw_position.token()?.clone();
        let kw_position_built = KwPosition { kw_position };
        // Calling user action here
        self.user_grammar.kw_position(&kw_position_built)?;
        self.push(ASTType::KwPosition(kw_position_built), context);
        Ok(())
    }

    /// Semantic action for production 46:
    ///
    /// `KwEnum: 'enum';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_enum(&mut self, kw_enum: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_enum = kw_enum.token()?.clone();
        let kw_enum_built = KwEnum { kw_enum };
        // Calling user action here
        self.user_grammar.kw_enum(&kw_enum_built)?;
        self.push(ASTType::KwEnum(kw_enum_built), context);
        Ok(())
    }

    /// Semantic action for production 47:
    ///
    /// `KwRevision: 'revision';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_revision(&mut self, kw_revision: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_revision = kw_revision.token()?.clone();
        let kw_revision_built = KwRevision { kw_revision };
        // Calling user action here
        self.user_grammar.kw_revision(&kw_revision_built)?;
        self.push(ASTType::KwRevision(kw_revision_built), context);
        Ok(())
    }

    /// Semantic action for production 48:
    ///
    /// `KwRevisionDate: 'revision-date';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_revision_date(&mut self, kw_revision_date: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_revision_date = kw_revision_date.token()?.clone();
        let kw_revision_date_built = KwRevisionDate { kw_revision_date };
        // Calling user action here
        self.user_grammar
            .kw_revision_date(&kw_revision_date_built)?;
        self.push(ASTType::KwRevisionDate(kw_revision_date_built), context);
        Ok(())
    }

    /// Semantic action for production 49:
    ///
    /// `KwNamespace: 'namespace';`
    ///
    #[parol_runtime::function_name::named]
    fn kw_namespace(&mut self, kw_namespace: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let kw_namespace = kw_namespace.token()?.clone();
        let kw_namespace_built = KwNamespace { kw_namespace };
        // Calling user action here
        self.user_grammar.kw_namespace(&kw_namespace_built)?;
        self.push(ASTType::KwNamespace(kw_namespace_built), context);
        Ok(())
    }

    /// Semantic action for production 50:
    ///
    /// `Yang: ModuleStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn yang_0(&mut self, _module_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt = pop_item!(self, module_stmt, ModuleStmt, context);
        let yang_0_built = YangModuleStmt {
            module_stmt: Box::new(module_stmt),
        };
        let yang_0_built = Yang::ModuleStmt(yang_0_built);
        // Calling user action here
        self.user_grammar.yang(&yang_0_built)?;
        self.push(ASTType::Yang(yang_0_built), context);
        Ok(())
    }

    /// Semantic action for production 51:
    ///
    /// `Yang: SubmoduleStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn yang_1(&mut self, _submodule_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt = pop_item!(self, submodule_stmt, SubmoduleStmt, context);
        let yang_1_built = YangSubmoduleStmt {
            submodule_stmt: Box::new(submodule_stmt),
        };
        let yang_1_built = Yang::SubmoduleStmt(yang_1_built);
        // Calling user action here
        self.user_grammar.yang(&yang_1_built)?;
        self.push(ASTType::Yang(yang_1_built), context);
        Ok(())
    }

    /// Semantic action for production 52:
    ///
    /// `ModuleStmt: KwModule^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ ModuleStmtList /* Vec */ ModuleStmtList0 /* Vec */ ModuleStmtList1 /* Vec */ ModuleStmtList2 /* Vec */ ModuleStmtList3 /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt(
        &mut self,
        _kw_module: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _module_stmt_list: &ParseTreeType<'t>,
        _module_stmt_list0: &ParseTreeType<'t>,
        _module_stmt_list1: &ParseTreeType<'t>,
        _module_stmt_list2: &ParseTreeType<'t>,
        _module_stmt_list3: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list3 =
            pop_and_reverse_item!(self, module_stmt_list3, ModuleStmtList3, context);
        let module_stmt_list2 =
            pop_and_reverse_item!(self, module_stmt_list2, ModuleStmtList2, context);
        let module_stmt_list1 =
            pop_and_reverse_item!(self, module_stmt_list1, ModuleStmtList1, context);
        let module_stmt_list0 =
            pop_and_reverse_item!(self, module_stmt_list0, ModuleStmtList0, context);
        let module_stmt_list =
            pop_and_reverse_item!(self, module_stmt_list, ModuleStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let module_stmt_built = ModuleStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            module_stmt_list,
            module_stmt_list0,
            module_stmt_list1,
            module_stmt_list2,
            module_stmt_list3,
        };
        // Calling user action here
        self.user_grammar.module_stmt(&module_stmt_built)?;
        self.push(ASTType::ModuleStmt(module_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 53:
    ///
    /// `ModuleStmtList3 /* Vec<T>::Push */: BodyStmts ModuleStmtList3;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list3_0(
        &mut self,
        _body_stmts: &ParseTreeType<'t>,
        _module_stmt_list3: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut module_stmt_list3 = pop_item!(self, module_stmt_list3, ModuleStmtList3, context);
        let body_stmts = pop_item!(self, body_stmts, BodyStmts, context);
        let module_stmt_list3_0_built = ModuleStmtList3 {
            body_stmts: Box::new(body_stmts),
        };
        // Add an element to the vector
        module_stmt_list3.push(module_stmt_list3_0_built);
        self.push(ASTType::ModuleStmtList3(module_stmt_list3), context);
        Ok(())
    }

    /// Semantic action for production 54:
    ///
    /// `ModuleStmtList3 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list3_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list3_1_built = Vec::new();
        self.push(ASTType::ModuleStmtList3(module_stmt_list3_1_built), context);
        Ok(())
    }

    /// Semantic action for production 55:
    ///
    /// `ModuleStmtList2 /* Vec<T>::Push */: RevisionStmt ModuleStmtList2;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list2_0(
        &mut self,
        _revision_stmt: &ParseTreeType<'t>,
        _module_stmt_list2: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut module_stmt_list2 = pop_item!(self, module_stmt_list2, ModuleStmtList2, context);
        let revision_stmt = pop_item!(self, revision_stmt, RevisionStmt, context);
        let module_stmt_list2_0_built = ModuleStmtList2 {
            revision_stmt: Box::new(revision_stmt),
        };
        // Add an element to the vector
        module_stmt_list2.push(module_stmt_list2_0_built);
        self.push(ASTType::ModuleStmtList2(module_stmt_list2), context);
        Ok(())
    }

    /// Semantic action for production 56:
    ///
    /// `ModuleStmtList2 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list2_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list2_1_built = Vec::new();
        self.push(ASTType::ModuleStmtList2(module_stmt_list2_1_built), context);
        Ok(())
    }

    /// Semantic action for production 57:
    ///
    /// `ModuleStmtList1 /* Vec<T>::Push */: MetaStmts ModuleStmtList1;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list1_0(
        &mut self,
        _meta_stmts: &ParseTreeType<'t>,
        _module_stmt_list1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut module_stmt_list1 = pop_item!(self, module_stmt_list1, ModuleStmtList1, context);
        let meta_stmts = pop_item!(self, meta_stmts, MetaStmts, context);
        let module_stmt_list1_0_built = ModuleStmtList1 {
            meta_stmts: Box::new(meta_stmts),
        };
        // Add an element to the vector
        module_stmt_list1.push(module_stmt_list1_0_built);
        self.push(ASTType::ModuleStmtList1(module_stmt_list1), context);
        Ok(())
    }

    /// Semantic action for production 58:
    ///
    /// `ModuleStmtList1 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list1_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list1_1_built = Vec::new();
        self.push(ASTType::ModuleStmtList1(module_stmt_list1_1_built), context);
        Ok(())
    }

    /// Semantic action for production 59:
    ///
    /// `ModuleStmtList0 /* Vec<T>::Push */: LinkageStmts ModuleStmtList0;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list0_0(
        &mut self,
        _linkage_stmts: &ParseTreeType<'t>,
        _module_stmt_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut module_stmt_list0 = pop_item!(self, module_stmt_list0, ModuleStmtList0, context);
        let linkage_stmts = pop_item!(self, linkage_stmts, LinkageStmts, context);
        let module_stmt_list0_0_built = ModuleStmtList0 {
            linkage_stmts: Box::new(linkage_stmts),
        };
        // Add an element to the vector
        module_stmt_list0.push(module_stmt_list0_0_built);
        self.push(ASTType::ModuleStmtList0(module_stmt_list0), context);
        Ok(())
    }

    /// Semantic action for production 60:
    ///
    /// `ModuleStmtList0 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list0_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list0_1_built = Vec::new();
        self.push(ASTType::ModuleStmtList0(module_stmt_list0_1_built), context);
        Ok(())
    }

    /// Semantic action for production 61:
    ///
    /// `ModuleStmtList /* Vec<T>::Push */: ModuleHeaderStmts ModuleStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list_0(
        &mut self,
        _module_header_stmts: &ParseTreeType<'t>,
        _module_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut module_stmt_list = pop_item!(self, module_stmt_list, ModuleStmtList, context);
        let module_header_stmts = pop_item!(self, module_header_stmts, ModuleHeaderStmts, context);
        let module_stmt_list_0_built = ModuleStmtList {
            module_header_stmts: Box::new(module_header_stmts),
        };
        // Add an element to the vector
        module_stmt_list.push(module_stmt_list_0_built);
        self.push(ASTType::ModuleStmtList(module_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 62:
    ///
    /// `ModuleStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn module_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let module_stmt_list_1_built = Vec::new();
        self.push(ASTType::ModuleStmtList(module_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 63:
    ///
    /// `SubmoduleStmt: KwSubmodule^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ SubmoduleStmtList /* Vec */ SubmoduleStmtList0 /* Vec */ SubmoduleStmtList1 /* Vec */ SubmoduleStmtList2 /* Vec */ SubmoduleStmtList3 /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt(
        &mut self,
        _kw_submodule: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _submodule_stmt_list: &ParseTreeType<'t>,
        _submodule_stmt_list0: &ParseTreeType<'t>,
        _submodule_stmt_list1: &ParseTreeType<'t>,
        _submodule_stmt_list2: &ParseTreeType<'t>,
        _submodule_stmt_list3: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list3 =
            pop_and_reverse_item!(self, submodule_stmt_list3, SubmoduleStmtList3, context);
        let submodule_stmt_list2 =
            pop_and_reverse_item!(self, submodule_stmt_list2, SubmoduleStmtList2, context);
        let submodule_stmt_list1 =
            pop_and_reverse_item!(self, submodule_stmt_list1, SubmoduleStmtList1, context);
        let submodule_stmt_list0 =
            pop_and_reverse_item!(self, submodule_stmt_list0, SubmoduleStmtList0, context);
        let submodule_stmt_list =
            pop_and_reverse_item!(self, submodule_stmt_list, SubmoduleStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let submodule_stmt_built = SubmoduleStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            submodule_stmt_list,
            submodule_stmt_list0,
            submodule_stmt_list1,
            submodule_stmt_list2,
            submodule_stmt_list3,
        };
        // Calling user action here
        self.user_grammar.submodule_stmt(&submodule_stmt_built)?;
        self.push(ASTType::SubmoduleStmt(submodule_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 64:
    ///
    /// `SubmoduleStmtList3 /* Vec<T>::Push */: BodyStmts SubmoduleStmtList3;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list3_0(
        &mut self,
        _body_stmts: &ParseTreeType<'t>,
        _submodule_stmt_list3: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut submodule_stmt_list3 =
            pop_item!(self, submodule_stmt_list3, SubmoduleStmtList3, context);
        let body_stmts = pop_item!(self, body_stmts, BodyStmts, context);
        let submodule_stmt_list3_0_built = SubmoduleStmtList3 {
            body_stmts: Box::new(body_stmts),
        };
        // Add an element to the vector
        submodule_stmt_list3.push(submodule_stmt_list3_0_built);
        self.push(ASTType::SubmoduleStmtList3(submodule_stmt_list3), context);
        Ok(())
    }

    /// Semantic action for production 65:
    ///
    /// `SubmoduleStmtList3 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list3_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list3_1_built = Vec::new();
        self.push(
            ASTType::SubmoduleStmtList3(submodule_stmt_list3_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 66:
    ///
    /// `SubmoduleStmtList2 /* Vec<T>::Push */: RevisionStmt SubmoduleStmtList2;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list2_0(
        &mut self,
        _revision_stmt: &ParseTreeType<'t>,
        _submodule_stmt_list2: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut submodule_stmt_list2 =
            pop_item!(self, submodule_stmt_list2, SubmoduleStmtList2, context);
        let revision_stmt = pop_item!(self, revision_stmt, RevisionStmt, context);
        let submodule_stmt_list2_0_built = SubmoduleStmtList2 {
            revision_stmt: Box::new(revision_stmt),
        };
        // Add an element to the vector
        submodule_stmt_list2.push(submodule_stmt_list2_0_built);
        self.push(ASTType::SubmoduleStmtList2(submodule_stmt_list2), context);
        Ok(())
    }

    /// Semantic action for production 67:
    ///
    /// `SubmoduleStmtList2 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list2_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list2_1_built = Vec::new();
        self.push(
            ASTType::SubmoduleStmtList2(submodule_stmt_list2_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 68:
    ///
    /// `SubmoduleStmtList1 /* Vec<T>::Push */: MetaStmts SubmoduleStmtList1;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list1_0(
        &mut self,
        _meta_stmts: &ParseTreeType<'t>,
        _submodule_stmt_list1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut submodule_stmt_list1 =
            pop_item!(self, submodule_stmt_list1, SubmoduleStmtList1, context);
        let meta_stmts = pop_item!(self, meta_stmts, MetaStmts, context);
        let submodule_stmt_list1_0_built = SubmoduleStmtList1 {
            meta_stmts: Box::new(meta_stmts),
        };
        // Add an element to the vector
        submodule_stmt_list1.push(submodule_stmt_list1_0_built);
        self.push(ASTType::SubmoduleStmtList1(submodule_stmt_list1), context);
        Ok(())
    }

    /// Semantic action for production 69:
    ///
    /// `SubmoduleStmtList1 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list1_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list1_1_built = Vec::new();
        self.push(
            ASTType::SubmoduleStmtList1(submodule_stmt_list1_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 70:
    ///
    /// `SubmoduleStmtList0 /* Vec<T>::Push */: LinkageStmts SubmoduleStmtList0;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list0_0(
        &mut self,
        _linkage_stmts: &ParseTreeType<'t>,
        _submodule_stmt_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut submodule_stmt_list0 =
            pop_item!(self, submodule_stmt_list0, SubmoduleStmtList0, context);
        let linkage_stmts = pop_item!(self, linkage_stmts, LinkageStmts, context);
        let submodule_stmt_list0_0_built = SubmoduleStmtList0 {
            linkage_stmts: Box::new(linkage_stmts),
        };
        // Add an element to the vector
        submodule_stmt_list0.push(submodule_stmt_list0_0_built);
        self.push(ASTType::SubmoduleStmtList0(submodule_stmt_list0), context);
        Ok(())
    }

    /// Semantic action for production 71:
    ///
    /// `SubmoduleStmtList0 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list0_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list0_1_built = Vec::new();
        self.push(
            ASTType::SubmoduleStmtList0(submodule_stmt_list0_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 72:
    ///
    /// `SubmoduleStmtList /* Vec<T>::Push */: SubmoduleHeaderStmts SubmoduleStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list_0(
        &mut self,
        _submodule_header_stmts: &ParseTreeType<'t>,
        _submodule_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut submodule_stmt_list =
            pop_item!(self, submodule_stmt_list, SubmoduleStmtList, context);
        let submodule_header_stmts =
            pop_item!(self, submodule_header_stmts, SubmoduleHeaderStmts, context);
        let submodule_stmt_list_0_built = SubmoduleStmtList {
            submodule_header_stmts: Box::new(submodule_header_stmts),
        };
        // Add an element to the vector
        submodule_stmt_list.push(submodule_stmt_list_0_built);
        self.push(ASTType::SubmoduleStmtList(submodule_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 73:
    ///
    /// `SubmoduleStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let submodule_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::SubmoduleStmtList(submodule_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 74:
    ///
    /// `ModuleHeaderStmts: YangVersionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn module_header_stmts_0(&mut self, _yang_version_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let yang_version_stmt = pop_item!(self, yang_version_stmt, YangVersionStmt, context);
        let module_header_stmts_0_built = ModuleHeaderStmtsYangVersionStmt {
            yang_version_stmt: Box::new(yang_version_stmt),
        };
        let module_header_stmts_0_built =
            ModuleHeaderStmts::YangVersionStmt(module_header_stmts_0_built);
        // Calling user action here
        self.user_grammar
            .module_header_stmts(&module_header_stmts_0_built)?;
        self.push(
            ASTType::ModuleHeaderStmts(module_header_stmts_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 75:
    ///
    /// `ModuleHeaderStmts: NamespaceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn module_header_stmts_1(&mut self, _namespace_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let namespace_stmt = pop_item!(self, namespace_stmt, NamespaceStmt, context);
        let module_header_stmts_1_built = ModuleHeaderStmtsNamespaceStmt {
            namespace_stmt: Box::new(namespace_stmt),
        };
        let module_header_stmts_1_built =
            ModuleHeaderStmts::NamespaceStmt(module_header_stmts_1_built);
        // Calling user action here
        self.user_grammar
            .module_header_stmts(&module_header_stmts_1_built)?;
        self.push(
            ASTType::ModuleHeaderStmts(module_header_stmts_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 76:
    ///
    /// `ModuleHeaderStmts: PrefixStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn module_header_stmts_2(&mut self, _prefix_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prefix_stmt = pop_item!(self, prefix_stmt, PrefixStmt, context);
        let module_header_stmts_2_built = ModuleHeaderStmtsPrefixStmt {
            prefix_stmt: Box::new(prefix_stmt),
        };
        let module_header_stmts_2_built =
            ModuleHeaderStmts::PrefixStmt(module_header_stmts_2_built);
        // Calling user action here
        self.user_grammar
            .module_header_stmts(&module_header_stmts_2_built)?;
        self.push(
            ASTType::ModuleHeaderStmts(module_header_stmts_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 77:
    ///
    /// `SubmoduleHeaderStmts: YangVersionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_header_stmts_0(&mut self, _yang_version_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let yang_version_stmt = pop_item!(self, yang_version_stmt, YangVersionStmt, context);
        let submodule_header_stmts_0_built = SubmoduleHeaderStmtsYangVersionStmt {
            yang_version_stmt: Box::new(yang_version_stmt),
        };
        let submodule_header_stmts_0_built =
            SubmoduleHeaderStmts::YangVersionStmt(submodule_header_stmts_0_built);
        // Calling user action here
        self.user_grammar
            .submodule_header_stmts(&submodule_header_stmts_0_built)?;
        self.push(
            ASTType::SubmoduleHeaderStmts(submodule_header_stmts_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 78:
    ///
    /// `SubmoduleHeaderStmts: BelongsToStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn submodule_header_stmts_1(&mut self, _belongs_to_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let belongs_to_stmt = pop_item!(self, belongs_to_stmt, BelongsToStmt, context);
        let submodule_header_stmts_1_built = SubmoduleHeaderStmtsBelongsToStmt {
            belongs_to_stmt: Box::new(belongs_to_stmt),
        };
        let submodule_header_stmts_1_built =
            SubmoduleHeaderStmts::BelongsToStmt(submodule_header_stmts_1_built);
        // Calling user action here
        self.user_grammar
            .submodule_header_stmts(&submodule_header_stmts_1_built)?;
        self.push(
            ASTType::SubmoduleHeaderStmts(submodule_header_stmts_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 79:
    ///
    /// `MetaStmts: OrganizationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn meta_stmts_0(&mut self, _organization_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let organization_stmt = pop_item!(self, organization_stmt, OrganizationStmt, context);
        let meta_stmts_0_built = MetaStmtsOrganizationStmt {
            organization_stmt: Box::new(organization_stmt),
        };
        let meta_stmts_0_built = MetaStmts::OrganizationStmt(meta_stmts_0_built);
        // Calling user action here
        self.user_grammar.meta_stmts(&meta_stmts_0_built)?;
        self.push(ASTType::MetaStmts(meta_stmts_0_built), context);
        Ok(())
    }

    /// Semantic action for production 80:
    ///
    /// `MetaStmts: ContactStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn meta_stmts_1(&mut self, _contact_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let contact_stmt = pop_item!(self, contact_stmt, ContactStmt, context);
        let meta_stmts_1_built = MetaStmtsContactStmt {
            contact_stmt: Box::new(contact_stmt),
        };
        let meta_stmts_1_built = MetaStmts::ContactStmt(meta_stmts_1_built);
        // Calling user action here
        self.user_grammar.meta_stmts(&meta_stmts_1_built)?;
        self.push(ASTType::MetaStmts(meta_stmts_1_built), context);
        Ok(())
    }

    /// Semantic action for production 81:
    ///
    /// `MetaStmts: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn meta_stmts_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let meta_stmts_2_built = MetaStmtsDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let meta_stmts_2_built = MetaStmts::DescriptionStmt(meta_stmts_2_built);
        // Calling user action here
        self.user_grammar.meta_stmts(&meta_stmts_2_built)?;
        self.push(ASTType::MetaStmts(meta_stmts_2_built), context);
        Ok(())
    }

    /// Semantic action for production 82:
    ///
    /// `MetaStmts: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn meta_stmts_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let meta_stmts_3_built = MetaStmtsReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let meta_stmts_3_built = MetaStmts::ReferenceStmt(meta_stmts_3_built);
        // Calling user action here
        self.user_grammar.meta_stmts(&meta_stmts_3_built)?;
        self.push(ASTType::MetaStmts(meta_stmts_3_built), context);
        Ok(())
    }

    /// Semantic action for production 83:
    ///
    /// `LinkageStmts: ImportStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn linkage_stmts_0(&mut self, _import_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let import_stmt = pop_item!(self, import_stmt, ImportStmt, context);
        let linkage_stmts_0_built = LinkageStmtsImportStmt {
            import_stmt: Box::new(import_stmt),
        };
        let linkage_stmts_0_built = LinkageStmts::ImportStmt(linkage_stmts_0_built);
        // Calling user action here
        self.user_grammar.linkage_stmts(&linkage_stmts_0_built)?;
        self.push(ASTType::LinkageStmts(linkage_stmts_0_built), context);
        Ok(())
    }

    /// Semantic action for production 84:
    ///
    /// `LinkageStmts: IncludeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn linkage_stmts_1(&mut self, _include_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let include_stmt = pop_item!(self, include_stmt, IncludeStmt, context);
        let linkage_stmts_1_built = LinkageStmtsIncludeStmt {
            include_stmt: Box::new(include_stmt),
        };
        let linkage_stmts_1_built = LinkageStmts::IncludeStmt(linkage_stmts_1_built);
        // Calling user action here
        self.user_grammar.linkage_stmts(&linkage_stmts_1_built)?;
        self.push(ASTType::LinkageStmts(linkage_stmts_1_built), context);
        Ok(())
    }

    /// Semantic action for production 85:
    ///
    /// `BodyStmts: ExtensionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_0(&mut self, _extension_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let extension_stmt = pop_item!(self, extension_stmt, ExtensionStmt, context);
        let body_stmts_0_built = BodyStmtsExtensionStmt {
            extension_stmt: Box::new(extension_stmt),
        };
        let body_stmts_0_built = BodyStmts::ExtensionStmt(body_stmts_0_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_0_built)?;
        self.push(ASTType::BodyStmts(body_stmts_0_built), context);
        Ok(())
    }

    /// Semantic action for production 86:
    ///
    /// `BodyStmts: FeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_1(&mut self, _feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let feature_stmt = pop_item!(self, feature_stmt, FeatureStmt, context);
        let body_stmts_1_built = BodyStmtsFeatureStmt {
            feature_stmt: Box::new(feature_stmt),
        };
        let body_stmts_1_built = BodyStmts::FeatureStmt(body_stmts_1_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_1_built)?;
        self.push(ASTType::BodyStmts(body_stmts_1_built), context);
        Ok(())
    }

    /// Semantic action for production 87:
    ///
    /// `BodyStmts: IdentityStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_2(&mut self, _identity_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identity_stmt = pop_item!(self, identity_stmt, IdentityStmt, context);
        let body_stmts_2_built = BodyStmtsIdentityStmt {
            identity_stmt: Box::new(identity_stmt),
        };
        let body_stmts_2_built = BodyStmts::IdentityStmt(body_stmts_2_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_2_built)?;
        self.push(ASTType::BodyStmts(body_stmts_2_built), context);
        Ok(())
    }

    /// Semantic action for production 88:
    ///
    /// `BodyStmts: TypedefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_3(&mut self, _typedef_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt = pop_item!(self, typedef_stmt, TypedefStmt, context);
        let body_stmts_3_built = BodyStmtsTypedefStmt {
            typedef_stmt: Box::new(typedef_stmt),
        };
        let body_stmts_3_built = BodyStmts::TypedefStmt(body_stmts_3_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_3_built)?;
        self.push(ASTType::BodyStmts(body_stmts_3_built), context);
        Ok(())
    }

    /// Semantic action for production 89:
    ///
    /// `BodyStmts: GroupingStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_4(&mut self, _grouping_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt = pop_item!(self, grouping_stmt, GroupingStmt, context);
        let body_stmts_4_built = BodyStmtsGroupingStmt {
            grouping_stmt: Box::new(grouping_stmt),
        };
        let body_stmts_4_built = BodyStmts::GroupingStmt(body_stmts_4_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_4_built)?;
        self.push(ASTType::BodyStmts(body_stmts_4_built), context);
        Ok(())
    }

    /// Semantic action for production 90:
    ///
    /// `BodyStmts: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_5(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let body_stmts_5_built = BodyStmtsDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let body_stmts_5_built = BodyStmts::DataDefStmt(body_stmts_5_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_5_built)?;
        self.push(ASTType::BodyStmts(body_stmts_5_built), context);
        Ok(())
    }

    /// Semantic action for production 91:
    ///
    /// `BodyStmts: AugmentStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_6(&mut self, _augment_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let augment_stmt = pop_item!(self, augment_stmt, AugmentStmt, context);
        let body_stmts_6_built = BodyStmtsAugmentStmt {
            augment_stmt: Box::new(augment_stmt),
        };
        let body_stmts_6_built = BodyStmts::AugmentStmt(body_stmts_6_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_6_built)?;
        self.push(ASTType::BodyStmts(body_stmts_6_built), context);
        Ok(())
    }

    /// Semantic action for production 92:
    ///
    /// `BodyStmts: RpcStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_7(&mut self, _rpc_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let rpc_stmt = pop_item!(self, rpc_stmt, RpcStmt, context);
        let body_stmts_7_built = BodyStmtsRpcStmt {
            rpc_stmt: Box::new(rpc_stmt),
        };
        let body_stmts_7_built = BodyStmts::RpcStmt(body_stmts_7_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_7_built)?;
        self.push(ASTType::BodyStmts(body_stmts_7_built), context);
        Ok(())
    }

    /// Semantic action for production 93:
    ///
    /// `BodyStmts: NotificationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_8(&mut self, _notification_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt = pop_item!(self, notification_stmt, NotificationStmt, context);
        let body_stmts_8_built = BodyStmtsNotificationStmt {
            notification_stmt: Box::new(notification_stmt),
        };
        let body_stmts_8_built = BodyStmts::NotificationStmt(body_stmts_8_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_8_built)?;
        self.push(ASTType::BodyStmts(body_stmts_8_built), context);
        Ok(())
    }

    /// Semantic action for production 94:
    ///
    /// `BodyStmts: DeviationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_9(&mut self, _deviation_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let deviation_stmt = pop_item!(self, deviation_stmt, DeviationStmt, context);
        let body_stmts_9_built = BodyStmtsDeviationStmt {
            deviation_stmt: Box::new(deviation_stmt),
        };
        let body_stmts_9_built = BodyStmts::DeviationStmt(body_stmts_9_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_9_built)?;
        self.push(ASTType::BodyStmts(body_stmts_9_built), context);
        Ok(())
    }

    /// Semantic action for production 95:
    ///
    /// `BodyStmts: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn body_stmts_10(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let body_stmts_10_built = BodyStmtsUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let body_stmts_10_built = BodyStmts::UnknownStmt(body_stmts_10_built);
        // Calling user action here
        self.user_grammar.body_stmts(&body_stmts_10_built)?;
        self.push(ASTType::BodyStmts(body_stmts_10_built), context);
        Ok(())
    }

    /// Semantic action for production 96:
    ///
    /// `DataDefStmt: ContainerStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_0(&mut self, _container_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let container_stmt = pop_item!(self, container_stmt, ContainerStmt, context);
        let data_def_stmt_0_built = DataDefStmtContainerStmt {
            container_stmt: Box::new(container_stmt),
        };
        let data_def_stmt_0_built = DataDefStmt::ContainerStmt(data_def_stmt_0_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_0_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_0_built), context);
        Ok(())
    }

    /// Semantic action for production 97:
    ///
    /// `DataDefStmt: LeafStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_1(&mut self, _leaf_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_stmt = pop_item!(self, leaf_stmt, LeafStmt, context);
        let data_def_stmt_1_built = DataDefStmtLeafStmt {
            leaf_stmt: Box::new(leaf_stmt),
        };
        let data_def_stmt_1_built = DataDefStmt::LeafStmt(data_def_stmt_1_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_1_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_1_built), context);
        Ok(())
    }

    /// Semantic action for production 98:
    ///
    /// `DataDefStmt: LeafListStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_2(&mut self, _leaf_list_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_list_stmt = pop_item!(self, leaf_list_stmt, LeafListStmt, context);
        let data_def_stmt_2_built = DataDefStmtLeafListStmt {
            leaf_list_stmt: Box::new(leaf_list_stmt),
        };
        let data_def_stmt_2_built = DataDefStmt::LeafListStmt(data_def_stmt_2_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_2_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_2_built), context);
        Ok(())
    }

    /// Semantic action for production 99:
    ///
    /// `DataDefStmt: ListStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_3(&mut self, _list_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let list_stmt = pop_item!(self, list_stmt, ListStmt, context);
        let data_def_stmt_3_built = DataDefStmtListStmt {
            list_stmt: Box::new(list_stmt),
        };
        let data_def_stmt_3_built = DataDefStmt::ListStmt(data_def_stmt_3_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_3_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_3_built), context);
        Ok(())
    }

    /// Semantic action for production 100:
    ///
    /// `DataDefStmt: ChoiceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_4(&mut self, _choice_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let choice_stmt = pop_item!(self, choice_stmt, ChoiceStmt, context);
        let data_def_stmt_4_built = DataDefStmtChoiceStmt {
            choice_stmt: Box::new(choice_stmt),
        };
        let data_def_stmt_4_built = DataDefStmt::ChoiceStmt(data_def_stmt_4_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_4_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_4_built), context);
        Ok(())
    }

    /// Semantic action for production 101:
    ///
    /// `DataDefStmt: AnydataStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_5(&mut self, _anydata_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anydata_stmt = pop_item!(self, anydata_stmt, AnydataStmt, context);
        let data_def_stmt_5_built = DataDefStmtAnydataStmt {
            anydata_stmt: Box::new(anydata_stmt),
        };
        let data_def_stmt_5_built = DataDefStmt::AnydataStmt(data_def_stmt_5_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_5_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_5_built), context);
        Ok(())
    }

    /// Semantic action for production 102:
    ///
    /// `DataDefStmt: AnyxmlStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_6(&mut self, _anyxml_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anyxml_stmt = pop_item!(self, anyxml_stmt, AnyxmlStmt, context);
        let data_def_stmt_6_built = DataDefStmtAnyxmlStmt {
            anyxml_stmt: Box::new(anyxml_stmt),
        };
        let data_def_stmt_6_built = DataDefStmt::AnyxmlStmt(data_def_stmt_6_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_6_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_6_built), context);
        Ok(())
    }

    /// Semantic action for production 103:
    ///
    /// `DataDefStmt: UsesStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn data_def_stmt_7(&mut self, _uses_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uses_stmt = pop_item!(self, uses_stmt, UsesStmt, context);
        let data_def_stmt_7_built = DataDefStmtUsesStmt {
            uses_stmt: Box::new(uses_stmt),
        };
        let data_def_stmt_7_built = DataDefStmt::UsesStmt(data_def_stmt_7_built);
        // Calling user action here
        self.user_grammar.data_def_stmt(&data_def_stmt_7_built)?;
        self.push(ASTType::DataDefStmt(data_def_stmt_7_built), context);
        Ok(())
    }

    /// Semantic action for production 104:
    ///
    /// `YangVersionStmt: KwYangVersion^ /* Clipped */ YangVersionArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn yang_version_stmt(
        &mut self,
        _kw_yang_version: &ParseTreeType<'t>,
        _yang_version_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let yang_version_arg_str =
            pop_item!(self, yang_version_arg_str, YangVersionArgStr, context);
        self.pop(context);
        let yang_version_stmt_built = YangVersionStmt {
            yang_version_arg_str: Box::new(yang_version_arg_str),
        };
        // Calling user action here
        self.user_grammar
            .yang_version_stmt(&yang_version_stmt_built)?;
        self.push(ASTType::YangVersionStmt(yang_version_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 105:
    ///
    /// `YangVersionArgStr: YangVersionArg;`
    ///
    #[parol_runtime::function_name::named]
    fn yang_version_arg_str_0(&mut self, _yang_version_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let yang_version_arg = pop_item!(self, yang_version_arg, YangVersionArg, context);
        let yang_version_arg_str_0_built = YangVersionArgStrYangVersionArg {
            yang_version_arg: Box::new(yang_version_arg),
        };
        let yang_version_arg_str_0_built =
            YangVersionArgStr::YangVersionArg(yang_version_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .yang_version_arg_str(&yang_version_arg_str_0_built)?;
        self.push(
            ASTType::YangVersionArgStr(yang_version_arg_str_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 106:
    ///
    /// `YangVersionArgStr: <YVersion>'"'^ /* Clipped */ YangVersionArg <YVersion>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn yang_version_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _yang_version_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let yang_version_arg = pop_item!(self, yang_version_arg, YangVersionArg, context);
        let yang_version_arg_str_1_built =
            YangVersionArgStrDoubleQuotationYangVersionArgDoubleQuotation {
                yang_version_arg: Box::new(yang_version_arg),
            };
        let yang_version_arg_str_1_built =
            YangVersionArgStr::DoubleQuotationYangVersionArgDoubleQuotation(
                yang_version_arg_str_1_built,
            );
        // Calling user action here
        self.user_grammar
            .yang_version_arg_str(&yang_version_arg_str_1_built)?;
        self.push(
            ASTType::YangVersionArgStr(yang_version_arg_str_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 107:
    ///
    /// `DeviationStmt: KwDeviation^ /* Clipped */ AbsoluteSchemaNodeid Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn deviation_stmt(
        &mut self,
        _kw_deviation: &ParseTreeType<'t>,
        _absolute_schema_nodeid: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let absolute_schema_nodeid =
            pop_item!(self, absolute_schema_nodeid, AbsoluteSchemaNodeid, context);
        self.pop(context);
        let deviation_stmt_built = DeviationStmt {
            absolute_schema_nodeid: Box::new(absolute_schema_nodeid),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.deviation_stmt(&deviation_stmt_built)?;
        self.push(ASTType::DeviationStmt(deviation_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 108:
    ///
    /// `RpcStmt: KwRpc^ /* Clipped */ IdentifierArgStr RpcStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt(
        &mut self,
        _kw_rpc: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _rpc_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let rpc_stmt_suffix = pop_item!(self, rpc_stmt_suffix, RpcStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let rpc_stmt_built = RpcStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            rpc_stmt_suffix: Box::new(rpc_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.rpc_stmt(&rpc_stmt_built)?;
        self.push(ASTType::RpcStmt(rpc_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 109:
    ///
    /// `RpcStmtSuffix: Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let rpc_stmt_suffix_0_built = RpcStmtSuffixSemicolon {
            semicolon: Box::new(semicolon),
        };
        let rpc_stmt_suffix_0_built = RpcStmtSuffix::Semicolon(rpc_stmt_suffix_0_built);
        self.push(ASTType::RpcStmtSuffix(rpc_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 110:
    ///
    /// `RpcStmtSuffix: LBrace^ /* Clipped */ RpcStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _rpc_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let rpc_stmt_list = pop_and_reverse_item!(self, rpc_stmt_list, RpcStmtList, context);
        self.pop(context);
        let rpc_stmt_suffix_1_built = RpcStmtSuffixLBraceRpcStmtListRBrace {
            rpc_stmt_list,
            r_brace,
        };
        let rpc_stmt_suffix_1_built =
            RpcStmtSuffix::LBraceRpcStmtListRBrace(rpc_stmt_suffix_1_built);
        self.push(ASTType::RpcStmtSuffix(rpc_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 111:
    ///
    /// `RpcStmtList /* Vec<T>::Push */: RpcStmtListGroup RpcStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_0(
        &mut self,
        _rpc_stmt_list_group: &ParseTreeType<'t>,
        _rpc_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut rpc_stmt_list = pop_item!(self, rpc_stmt_list, RpcStmtList, context);
        let rpc_stmt_list_group = pop_item!(self, rpc_stmt_list_group, RpcStmtListGroup, context);
        let rpc_stmt_list_0_built = RpcStmtList {
            rpc_stmt_list_group: Box::new(rpc_stmt_list_group),
        };
        // Add an element to the vector
        rpc_stmt_list.push(rpc_stmt_list_0_built);
        self.push(ASTType::RpcStmtList(rpc_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 112:
    ///
    /// `RpcStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let rpc_stmt_list_group_0_built = RpcStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let rpc_stmt_list_group_0_built =
            RpcStmtListGroup::IfFeatureStmt(rpc_stmt_list_group_0_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 113:
    ///
    /// `RpcStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_1(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let rpc_stmt_list_group_1_built = RpcStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let rpc_stmt_list_group_1_built = RpcStmtListGroup::StatusStmt(rpc_stmt_list_group_1_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 114:
    ///
    /// `RpcStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let rpc_stmt_list_group_2_built = RpcStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let rpc_stmt_list_group_2_built =
            RpcStmtListGroup::DescriptionStmt(rpc_stmt_list_group_2_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 115:
    ///
    /// `RpcStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let rpc_stmt_list_group_3_built = RpcStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let rpc_stmt_list_group_3_built =
            RpcStmtListGroup::ReferenceStmt(rpc_stmt_list_group_3_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 116:
    ///
    /// `RpcStmtListGroup: TypedefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_4(&mut self, _typedef_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt = pop_item!(self, typedef_stmt, TypedefStmt, context);
        let rpc_stmt_list_group_4_built = RpcStmtListGroupTypedefStmt {
            typedef_stmt: Box::new(typedef_stmt),
        };
        let rpc_stmt_list_group_4_built =
            RpcStmtListGroup::TypedefStmt(rpc_stmt_list_group_4_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 117:
    ///
    /// `RpcStmtListGroup: GroupingStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_5(&mut self, _grouping_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt = pop_item!(self, grouping_stmt, GroupingStmt, context);
        let rpc_stmt_list_group_5_built = RpcStmtListGroupGroupingStmt {
            grouping_stmt: Box::new(grouping_stmt),
        };
        let rpc_stmt_list_group_5_built =
            RpcStmtListGroup::GroupingStmt(rpc_stmt_list_group_5_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 118:
    ///
    /// `RpcStmtListGroup: InputStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_6(&mut self, _input_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let input_stmt = pop_item!(self, input_stmt, InputStmt, context);
        let rpc_stmt_list_group_6_built = RpcStmtListGroupInputStmt {
            input_stmt: Box::new(input_stmt),
        };
        let rpc_stmt_list_group_6_built = RpcStmtListGroup::InputStmt(rpc_stmt_list_group_6_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 119:
    ///
    /// `RpcStmtListGroup: OutputStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_group_7(&mut self, _output_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let output_stmt = pop_item!(self, output_stmt, OutputStmt, context);
        let rpc_stmt_list_group_7_built = RpcStmtListGroupOutputStmt {
            output_stmt: Box::new(output_stmt),
        };
        let rpc_stmt_list_group_7_built = RpcStmtListGroup::OutputStmt(rpc_stmt_list_group_7_built);
        self.push(
            ASTType::RpcStmtListGroup(rpc_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 120:
    ///
    /// `RpcStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn rpc_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let rpc_stmt_list_1_built = Vec::new();
        self.push(ASTType::RpcStmtList(rpc_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 121:
    ///
    /// `ExtensionStmt: KwExtension^ /* Clipped */ IdentifierArgStr ExtensionStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt(
        &mut self,
        _kw_extension: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _extension_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let extension_stmt_suffix =
            pop_item!(self, extension_stmt_suffix, ExtensionStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let extension_stmt_built = ExtensionStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            extension_stmt_suffix: Box::new(extension_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.extension_stmt(&extension_stmt_built)?;
        self.push(ASTType::ExtensionStmt(extension_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 122:
    ///
    /// `ExtensionStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let extension_stmt_suffix_0_built = ExtensionStmtSuffixSemicolon {};
        let extension_stmt_suffix_0_built =
            ExtensionStmtSuffix::Semicolon(extension_stmt_suffix_0_built);
        self.push(
            ASTType::ExtensionStmtSuffix(extension_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 123:
    ///
    /// `ExtensionStmtSuffix: LBrace^ /* Clipped */ ExtensionStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _extension_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let extension_stmt_list =
            pop_and_reverse_item!(self, extension_stmt_list, ExtensionStmtList, context);
        self.pop(context);
        let extension_stmt_suffix_1_built = ExtensionStmtSuffixLBraceExtensionStmtListRBrace {
            extension_stmt_list,
        };
        let extension_stmt_suffix_1_built =
            ExtensionStmtSuffix::LBraceExtensionStmtListRBrace(extension_stmt_suffix_1_built);
        self.push(
            ASTType::ExtensionStmtSuffix(extension_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 124:
    ///
    /// `ExtensionStmtList /* Vec<T>::Push */: ExtensionStmtListGroup ExtensionStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_0(
        &mut self,
        _extension_stmt_list_group: &ParseTreeType<'t>,
        _extension_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut extension_stmt_list =
            pop_item!(self, extension_stmt_list, ExtensionStmtList, context);
        let extension_stmt_list_group = pop_item!(
            self,
            extension_stmt_list_group,
            ExtensionStmtListGroup,
            context
        );
        let extension_stmt_list_0_built = ExtensionStmtList {
            extension_stmt_list_group: Box::new(extension_stmt_list_group),
        };
        // Add an element to the vector
        extension_stmt_list.push(extension_stmt_list_0_built);
        self.push(ASTType::ExtensionStmtList(extension_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 125:
    ///
    /// `ExtensionStmtListGroup: ArgumentStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_group_0(&mut self, _argument_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let argument_stmt = pop_item!(self, argument_stmt, ArgumentStmt, context);
        let extension_stmt_list_group_0_built = ExtensionStmtListGroupArgumentStmt {
            argument_stmt: Box::new(argument_stmt),
        };
        let extension_stmt_list_group_0_built =
            ExtensionStmtListGroup::ArgumentStmt(extension_stmt_list_group_0_built);
        self.push(
            ASTType::ExtensionStmtListGroup(extension_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 126:
    ///
    /// `ExtensionStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_group_1(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let extension_stmt_list_group_1_built = ExtensionStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let extension_stmt_list_group_1_built =
            ExtensionStmtListGroup::StatusStmt(extension_stmt_list_group_1_built);
        self.push(
            ASTType::ExtensionStmtListGroup(extension_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 127:
    ///
    /// `ExtensionStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let extension_stmt_list_group_2_built = ExtensionStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let extension_stmt_list_group_2_built =
            ExtensionStmtListGroup::DescriptionStmt(extension_stmt_list_group_2_built);
        self.push(
            ASTType::ExtensionStmtListGroup(extension_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 128:
    ///
    /// `ExtensionStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let extension_stmt_list_group_3_built = ExtensionStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let extension_stmt_list_group_3_built =
            ExtensionStmtListGroup::ReferenceStmt(extension_stmt_list_group_3_built);
        self.push(
            ASTType::ExtensionStmtListGroup(extension_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 129:
    ///
    /// `ExtensionStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let extension_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::ExtensionStmtList(extension_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 130:
    ///
    /// `ArgumentStmt: KwArgument^ /* Clipped */ IdentifierArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn argument_stmt(
        &mut self,
        _kw_argument: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let argument_stmt_built = ArgumentStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
        };
        // Calling user action here
        self.user_grammar.argument_stmt(&argument_stmt_built)?;
        self.push(ASTType::ArgumentStmt(argument_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 131:
    ///
    /// `FeatureStmt: KwFeature^ /* Clipped */ IdentifierArgStr FeatureStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt(
        &mut self,
        _kw_feature: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _feature_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let feature_stmt_suffix = pop_item!(self, feature_stmt_suffix, FeatureStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let feature_stmt_built = FeatureStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            feature_stmt_suffix: Box::new(feature_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.feature_stmt(&feature_stmt_built)?;
        self.push(ASTType::FeatureStmt(feature_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 132:
    ///
    /// `FeatureStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let feature_stmt_suffix_0_built = FeatureStmtSuffixSemicolon {};
        let feature_stmt_suffix_0_built = FeatureStmtSuffix::Semicolon(feature_stmt_suffix_0_built);
        self.push(
            ASTType::FeatureStmtSuffix(feature_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 133:
    ///
    /// `FeatureStmtSuffix: LBrace^ /* Clipped */ FeatureStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _feature_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let feature_stmt_list =
            pop_and_reverse_item!(self, feature_stmt_list, FeatureStmtList, context);
        self.pop(context);
        let feature_stmt_suffix_1_built = FeatureStmtSuffixLBraceFeatureStmtListRBrace {
            feature_stmt_list,
            r_brace,
        };
        let feature_stmt_suffix_1_built =
            FeatureStmtSuffix::LBraceFeatureStmtListRBrace(feature_stmt_suffix_1_built);
        self.push(
            ASTType::FeatureStmtSuffix(feature_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 134:
    ///
    /// `FeatureStmtList /* Vec<T>::Push */: FeatureStmtListGroup FeatureStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_0(
        &mut self,
        _feature_stmt_list_group: &ParseTreeType<'t>,
        _feature_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut feature_stmt_list = pop_item!(self, feature_stmt_list, FeatureStmtList, context);
        let feature_stmt_list_group =
            pop_item!(self, feature_stmt_list_group, FeatureStmtListGroup, context);
        let feature_stmt_list_0_built = FeatureStmtList {
            feature_stmt_list_group: Box::new(feature_stmt_list_group),
        };
        // Add an element to the vector
        feature_stmt_list.push(feature_stmt_list_0_built);
        self.push(ASTType::FeatureStmtList(feature_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 135:
    ///
    /// `FeatureStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let feature_stmt_list_group_0_built = FeatureStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let feature_stmt_list_group_0_built =
            FeatureStmtListGroup::IfFeatureStmt(feature_stmt_list_group_0_built);
        self.push(
            ASTType::FeatureStmtListGroup(feature_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 136:
    ///
    /// `FeatureStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_group_1(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let feature_stmt_list_group_1_built = FeatureStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let feature_stmt_list_group_1_built =
            FeatureStmtListGroup::StatusStmt(feature_stmt_list_group_1_built);
        self.push(
            ASTType::FeatureStmtListGroup(feature_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 137:
    ///
    /// `FeatureStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let feature_stmt_list_group_2_built = FeatureStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let feature_stmt_list_group_2_built =
            FeatureStmtListGroup::DescriptionStmt(feature_stmt_list_group_2_built);
        self.push(
            ASTType::FeatureStmtListGroup(feature_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 138:
    ///
    /// `FeatureStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let feature_stmt_list_group_3_built = FeatureStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let feature_stmt_list_group_3_built =
            FeatureStmtListGroup::ReferenceStmt(feature_stmt_list_group_3_built);
        self.push(
            ASTType::FeatureStmtListGroup(feature_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 139:
    ///
    /// `FeatureStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn feature_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let feature_stmt_list_1_built = Vec::new();
        self.push(ASTType::FeatureStmtList(feature_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 140:
    ///
    /// `TypedefStmt: KwTypedef^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ TypedefStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt(
        &mut self,
        _kw_typedef: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _typedef_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt_list =
            pop_and_reverse_item!(self, typedef_stmt_list, TypedefStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let typedef_stmt_built = TypedefStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            typedef_stmt_list,
        };
        // Calling user action here
        self.user_grammar.typedef_stmt(&typedef_stmt_built)?;
        self.push(ASTType::TypedefStmt(typedef_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 141:
    ///
    /// `TypedefStmtList /* Vec<T>::Push */: TypedefStmtListGroup TypedefStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_0(
        &mut self,
        _typedef_stmt_list_group: &ParseTreeType<'t>,
        _typedef_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut typedef_stmt_list = pop_item!(self, typedef_stmt_list, TypedefStmtList, context);
        let typedef_stmt_list_group =
            pop_item!(self, typedef_stmt_list_group, TypedefStmtListGroup, context);
        let typedef_stmt_list_0_built = TypedefStmtList {
            typedef_stmt_list_group: Box::new(typedef_stmt_list_group),
        };
        // Add an element to the vector
        typedef_stmt_list.push(typedef_stmt_list_0_built);
        self.push(ASTType::TypedefStmtList(typedef_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 142:
    ///
    /// `TypedefStmtListGroup: TypeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_0(&mut self, _type_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt = pop_item!(self, type_stmt, TypeStmt, context);
        let typedef_stmt_list_group_0_built = TypedefStmtListGroupTypeStmt {
            type_stmt: Box::new(type_stmt),
        };
        let typedef_stmt_list_group_0_built =
            TypedefStmtListGroup::TypeStmt(typedef_stmt_list_group_0_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 143:
    ///
    /// `TypedefStmtListGroup: UnitsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_1(&mut self, _units_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let units_stmt = pop_item!(self, units_stmt, UnitsStmt, context);
        let typedef_stmt_list_group_1_built = TypedefStmtListGroupUnitsStmt {
            units_stmt: Box::new(units_stmt),
        };
        let typedef_stmt_list_group_1_built =
            TypedefStmtListGroup::UnitsStmt(typedef_stmt_list_group_1_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 144:
    ///
    /// `TypedefStmtListGroup: DefaultStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_2(&mut self, _default_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt = pop_item!(self, default_stmt, DefaultStmt, context);
        let typedef_stmt_list_group_2_built = TypedefStmtListGroupDefaultStmt {
            default_stmt: Box::new(default_stmt),
        };
        let typedef_stmt_list_group_2_built =
            TypedefStmtListGroup::DefaultStmt(typedef_stmt_list_group_2_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 145:
    ///
    /// `TypedefStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_3(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let typedef_stmt_list_group_3_built = TypedefStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let typedef_stmt_list_group_3_built =
            TypedefStmtListGroup::StatusStmt(typedef_stmt_list_group_3_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 146:
    ///
    /// `TypedefStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_4(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let typedef_stmt_list_group_4_built = TypedefStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let typedef_stmt_list_group_4_built =
            TypedefStmtListGroup::DescriptionStmt(typedef_stmt_list_group_4_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 147:
    ///
    /// `TypedefStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_group_5(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let typedef_stmt_list_group_5_built = TypedefStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let typedef_stmt_list_group_5_built =
            TypedefStmtListGroup::ReferenceStmt(typedef_stmt_list_group_5_built);
        self.push(
            ASTType::TypedefStmtListGroup(typedef_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 148:
    ///
    /// `TypedefStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn typedef_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt_list_1_built = Vec::new();
        self.push(ASTType::TypedefStmtList(typedef_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 149:
    ///
    /// `AugmentStmt: 'augment'^ /* Clipped */ AugmentArgStr LBrace^ /* Clipped */ AugmentStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt(
        &mut self,
        _augment: &ParseTreeType<'t>,
        _augment_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _augment_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let augment_stmt_list =
            pop_and_reverse_item!(self, augment_stmt_list, AugmentStmtList, context);
        self.pop(context);
        let augment_arg_str = pop_item!(self, augment_arg_str, AugmentArgStr, context);
        let augment_stmt_built = AugmentStmt {
            augment_arg_str: Box::new(augment_arg_str),
            augment_stmt_list,
        };
        // Calling user action here
        self.user_grammar.augment_stmt(&augment_stmt_built)?;
        self.push(ASTType::AugmentStmt(augment_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 150:
    ///
    /// `AugmentStmtList /* Vec<T>::Push */: AugmentStmtListGroup AugmentStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_0(
        &mut self,
        _augment_stmt_list_group: &ParseTreeType<'t>,
        _augment_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut augment_stmt_list = pop_item!(self, augment_stmt_list, AugmentStmtList, context);
        let augment_stmt_list_group =
            pop_item!(self, augment_stmt_list_group, AugmentStmtListGroup, context);
        let augment_stmt_list_0_built = AugmentStmtList {
            augment_stmt_list_group: Box::new(augment_stmt_list_group),
        };
        // Add an element to the vector
        augment_stmt_list.push(augment_stmt_list_0_built);
        self.push(ASTType::AugmentStmtList(augment_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 151:
    ///
    /// `AugmentStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let augment_stmt_list_group_0_built = AugmentStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let augment_stmt_list_group_0_built =
            AugmentStmtListGroup::WhenStmt(augment_stmt_list_group_0_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 152:
    ///
    /// `AugmentStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let augment_stmt_list_group_1_built = AugmentStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let augment_stmt_list_group_1_built =
            AugmentStmtListGroup::IfFeatureStmt(augment_stmt_list_group_1_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 153:
    ///
    /// `AugmentStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_2(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let augment_stmt_list_group_2_built = AugmentStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let augment_stmt_list_group_2_built =
            AugmentStmtListGroup::StatusStmt(augment_stmt_list_group_2_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 154:
    ///
    /// `AugmentStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_3(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let augment_stmt_list_group_3_built = AugmentStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let augment_stmt_list_group_3_built =
            AugmentStmtListGroup::DescriptionStmt(augment_stmt_list_group_3_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 155:
    ///
    /// `AugmentStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_4(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let augment_stmt_list_group_4_built = AugmentStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let augment_stmt_list_group_4_built =
            AugmentStmtListGroup::ReferenceStmt(augment_stmt_list_group_4_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 156:
    ///
    /// `AugmentStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_5(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let augment_stmt_list_group_5_built = AugmentStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let augment_stmt_list_group_5_built =
            AugmentStmtListGroup::DataDefStmt(augment_stmt_list_group_5_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 157:
    ///
    /// `AugmentStmtListGroup: CaseStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_6(&mut self, _case_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let case_stmt = pop_item!(self, case_stmt, CaseStmt, context);
        let augment_stmt_list_group_6_built = AugmentStmtListGroupCaseStmt {
            case_stmt: Box::new(case_stmt),
        };
        let augment_stmt_list_group_6_built =
            AugmentStmtListGroup::CaseStmt(augment_stmt_list_group_6_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 158:
    ///
    /// `AugmentStmtListGroup: ActionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_7(&mut self, _action_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt = pop_item!(self, action_stmt, ActionStmt, context);
        let augment_stmt_list_group_7_built = AugmentStmtListGroupActionStmt {
            action_stmt: Box::new(action_stmt),
        };
        let augment_stmt_list_group_7_built =
            AugmentStmtListGroup::ActionStmt(augment_stmt_list_group_7_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 159:
    ///
    /// `AugmentStmtListGroup: NotificationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_group_8(&mut self, _notification_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt = pop_item!(self, notification_stmt, NotificationStmt, context);
        let augment_stmt_list_group_8_built = AugmentStmtListGroupNotificationStmt {
            notification_stmt: Box::new(notification_stmt),
        };
        let augment_stmt_list_group_8_built =
            AugmentStmtListGroup::NotificationStmt(augment_stmt_list_group_8_built);
        self.push(
            ASTType::AugmentStmtListGroup(augment_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 160:
    ///
    /// `AugmentStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let augment_stmt_list_1_built = Vec::new();
        self.push(ASTType::AugmentStmtList(augment_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 161:
    ///
    /// `AugmentArgStr: Ystring;`
    ///
    #[parol_runtime::function_name::named]
    fn augment_arg_str(&mut self, _ystring: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ystring = pop_item!(self, ystring, Ystring, context);
        let augment_arg_str_built = AugmentArgStr {
            ystring: Box::new(ystring),
        };
        // Calling user action here
        self.user_grammar.augment_arg_str(&augment_arg_str_built)?;
        self.push(ASTType::AugmentArgStr(augment_arg_str_built), context);
        Ok(())
    }

    /// Semantic action for production 162:
    ///
    /// `WhenStmt: 'when'^ /* Clipped */ Ystring WhenStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt(
        &mut self,
        _when: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _when_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt_suffix = pop_item!(self, when_stmt_suffix, WhenStmtSuffix, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let when_stmt_built = WhenStmt {
            ystring: Box::new(ystring),
            when_stmt_suffix: Box::new(when_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.when_stmt(&when_stmt_built)?;
        self.push(ASTType::WhenStmt(when_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 163:
    ///
    /// `WhenStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let when_stmt_suffix_0_built = WhenStmtSuffixSemicolon {};
        let when_stmt_suffix_0_built = WhenStmtSuffix::Semicolon(when_stmt_suffix_0_built);
        self.push(ASTType::WhenStmtSuffix(when_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 164:
    ///
    /// `WhenStmtSuffix: LBrace^ /* Clipped */ WhenStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _when_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let when_stmt_list = pop_and_reverse_item!(self, when_stmt_list, WhenStmtList, context);
        self.pop(context);
        let when_stmt_suffix_1_built = WhenStmtSuffixLBraceWhenStmtListRBrace {
            when_stmt_list,
            r_brace,
        };
        let when_stmt_suffix_1_built =
            WhenStmtSuffix::LBraceWhenStmtListRBrace(when_stmt_suffix_1_built);
        self.push(ASTType::WhenStmtSuffix(when_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 165:
    ///
    /// `WhenStmtList /* Vec<T>::Push */: WhenStmtListGroup WhenStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_list_0(
        &mut self,
        _when_stmt_list_group: &ParseTreeType<'t>,
        _when_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut when_stmt_list = pop_item!(self, when_stmt_list, WhenStmtList, context);
        let when_stmt_list_group =
            pop_item!(self, when_stmt_list_group, WhenStmtListGroup, context);
        let when_stmt_list_0_built = WhenStmtList {
            when_stmt_list_group: Box::new(when_stmt_list_group),
        };
        // Add an element to the vector
        when_stmt_list.push(when_stmt_list_0_built);
        self.push(ASTType::WhenStmtList(when_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 166:
    ///
    /// `WhenStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_list_group_0(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let when_stmt_list_group_0_built = WhenStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let when_stmt_list_group_0_built =
            WhenStmtListGroup::DescriptionStmt(when_stmt_list_group_0_built);
        self.push(
            ASTType::WhenStmtListGroup(when_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 167:
    ///
    /// `WhenStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_list_group_1(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let when_stmt_list_group_1_built = WhenStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let when_stmt_list_group_1_built =
            WhenStmtListGroup::ReferenceStmt(when_stmt_list_group_1_built);
        self.push(
            ASTType::WhenStmtListGroup(when_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 168:
    ///
    /// `WhenStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn when_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt_list_1_built = Vec::new();
        self.push(ASTType::WhenStmtList(when_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 169:
    ///
    /// `GroupingStmt: KwGrouping^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ GroupingStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt(
        &mut self,
        _kw_grouping: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _grouping_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt_list =
            pop_and_reverse_item!(self, grouping_stmt_list, GroupingStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let grouping_stmt_built = GroupingStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            grouping_stmt_list,
        };
        // Calling user action here
        self.user_grammar.grouping_stmt(&grouping_stmt_built)?;
        self.push(ASTType::GroupingStmt(grouping_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 170:
    ///
    /// `GroupingStmtList /* Vec<T>::Push */: GroupingStmtListGroup GroupingStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_0(
        &mut self,
        _grouping_stmt_list_group: &ParseTreeType<'t>,
        _grouping_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut grouping_stmt_list = pop_item!(self, grouping_stmt_list, GroupingStmtList, context);
        let grouping_stmt_list_group = pop_item!(
            self,
            grouping_stmt_list_group,
            GroupingStmtListGroup,
            context
        );
        let grouping_stmt_list_0_built = GroupingStmtList {
            grouping_stmt_list_group: Box::new(grouping_stmt_list_group),
        };
        // Add an element to the vector
        grouping_stmt_list.push(grouping_stmt_list_0_built);
        self.push(ASTType::GroupingStmtList(grouping_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 171:
    ///
    /// `GroupingStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_0(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let grouping_stmt_list_group_0_built = GroupingStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let grouping_stmt_list_group_0_built =
            GroupingStmtListGroup::StatusStmt(grouping_stmt_list_group_0_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 172:
    ///
    /// `GroupingStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let grouping_stmt_list_group_1_built = GroupingStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let grouping_stmt_list_group_1_built =
            GroupingStmtListGroup::DescriptionStmt(grouping_stmt_list_group_1_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 173:
    ///
    /// `GroupingStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_2(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let grouping_stmt_list_group_2_built = GroupingStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let grouping_stmt_list_group_2_built =
            GroupingStmtListGroup::ReferenceStmt(grouping_stmt_list_group_2_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 174:
    ///
    /// `GroupingStmtListGroup: TypedefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_3(&mut self, _typedef_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt = pop_item!(self, typedef_stmt, TypedefStmt, context);
        let grouping_stmt_list_group_3_built = GroupingStmtListGroupTypedefStmt {
            typedef_stmt: Box::new(typedef_stmt),
        };
        let grouping_stmt_list_group_3_built =
            GroupingStmtListGroup::TypedefStmt(grouping_stmt_list_group_3_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 175:
    ///
    /// `GroupingStmtListGroup: GroupingStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_4(&mut self, _grouping_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt = pop_item!(self, grouping_stmt, GroupingStmt, context);
        let grouping_stmt_list_group_4_built = GroupingStmtListGroupGroupingStmt {
            grouping_stmt: Box::new(grouping_stmt),
        };
        let grouping_stmt_list_group_4_built =
            GroupingStmtListGroup::GroupingStmt(grouping_stmt_list_group_4_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 176:
    ///
    /// `GroupingStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_5(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let grouping_stmt_list_group_5_built = GroupingStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let grouping_stmt_list_group_5_built =
            GroupingStmtListGroup::DataDefStmt(grouping_stmt_list_group_5_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 177:
    ///
    /// `GroupingStmtListGroup: ActionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_6(&mut self, _action_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt = pop_item!(self, action_stmt, ActionStmt, context);
        let grouping_stmt_list_group_6_built = GroupingStmtListGroupActionStmt {
            action_stmt: Box::new(action_stmt),
        };
        let grouping_stmt_list_group_6_built =
            GroupingStmtListGroup::ActionStmt(grouping_stmt_list_group_6_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 178:
    ///
    /// `GroupingStmtListGroup: NotificationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_7(&mut self, _notification_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt = pop_item!(self, notification_stmt, NotificationStmt, context);
        let grouping_stmt_list_group_7_built = GroupingStmtListGroupNotificationStmt {
            notification_stmt: Box::new(notification_stmt),
        };
        let grouping_stmt_list_group_7_built =
            GroupingStmtListGroup::NotificationStmt(grouping_stmt_list_group_7_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 179:
    ///
    /// `GroupingStmtListGroup: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_group_8(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let grouping_stmt_list_group_8_built = GroupingStmtListGroupUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let grouping_stmt_list_group_8_built =
            GroupingStmtListGroup::UnknownStmt(grouping_stmt_list_group_8_built);
        self.push(
            ASTType::GroupingStmtListGroup(grouping_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 180:
    ///
    /// `GroupingStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn grouping_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::GroupingStmtList(grouping_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 181:
    ///
    /// `IdentityStmt: KwIdentity^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ IdentityStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt(
        &mut self,
        _kw_identity: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _identity_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identity_stmt_list =
            pop_and_reverse_item!(self, identity_stmt_list, IdentityStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let identity_stmt_built = IdentityStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            identity_stmt_list,
        };
        // Calling user action here
        self.user_grammar.identity_stmt(&identity_stmt_built)?;
        self.push(ASTType::IdentityStmt(identity_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 182:
    ///
    /// `IdentityStmtList /* Vec<T>::Push */: IdentityStmtListGroup IdentityStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_0(
        &mut self,
        _identity_stmt_list_group: &ParseTreeType<'t>,
        _identity_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut identity_stmt_list = pop_item!(self, identity_stmt_list, IdentityStmtList, context);
        let identity_stmt_list_group = pop_item!(
            self,
            identity_stmt_list_group,
            IdentityStmtListGroup,
            context
        );
        let identity_stmt_list_0_built = IdentityStmtList {
            identity_stmt_list_group: Box::new(identity_stmt_list_group),
        };
        // Add an element to the vector
        identity_stmt_list.push(identity_stmt_list_0_built);
        self.push(ASTType::IdentityStmtList(identity_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 183:
    ///
    /// `IdentityStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let identity_stmt_list_group_0_built = IdentityStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let identity_stmt_list_group_0_built =
            IdentityStmtListGroup::IfFeatureStmt(identity_stmt_list_group_0_built);
        self.push(
            ASTType::IdentityStmtListGroup(identity_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 184:
    ///
    /// `IdentityStmtListGroup: BaseStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_group_1(&mut self, _base_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let base_stmt = pop_item!(self, base_stmt, BaseStmt, context);
        let identity_stmt_list_group_1_built = IdentityStmtListGroupBaseStmt {
            base_stmt: Box::new(base_stmt),
        };
        let identity_stmt_list_group_1_built =
            IdentityStmtListGroup::BaseStmt(identity_stmt_list_group_1_built);
        self.push(
            ASTType::IdentityStmtListGroup(identity_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 185:
    ///
    /// `IdentityStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let identity_stmt_list_group_2_built = IdentityStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let identity_stmt_list_group_2_built =
            IdentityStmtListGroup::DescriptionStmt(identity_stmt_list_group_2_built);
        self.push(
            ASTType::IdentityStmtListGroup(identity_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 186:
    ///
    /// `IdentityStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let identity_stmt_list_group_3_built = IdentityStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let identity_stmt_list_group_3_built =
            IdentityStmtListGroup::ReferenceStmt(identity_stmt_list_group_3_built);
        self.push(
            ASTType::IdentityStmtListGroup(identity_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 187:
    ///
    /// `IdentityStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn identity_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identity_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::IdentityStmtList(identity_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 188:
    ///
    /// `BaseStmt: KwBase^ /* Clipped */ IdentifierRefArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn base_stmt(
        &mut self,
        _kw_base: &ParseTreeType<'t>,
        _identifier_ref_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let identifier_ref_arg_str =
            pop_item!(self, identifier_ref_arg_str, IdentifierRefArgStr, context);
        self.pop(context);
        let base_stmt_built = BaseStmt {
            identifier_ref_arg_str: Box::new(identifier_ref_arg_str),
        };
        // Calling user action here
        self.user_grammar.base_stmt(&base_stmt_built)?;
        self.push(ASTType::BaseStmt(base_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 189:
    ///
    /// `AnyxmlStmt: KwAnyxml^ /* Clipped */ IdentifierArgStr AnyxmlStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt(
        &mut self,
        _kw_anyxml: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _anyxml_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anyxml_stmt_suffix = pop_item!(self, anyxml_stmt_suffix, AnyxmlStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let anyxml_stmt_built = AnyxmlStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            anyxml_stmt_suffix: Box::new(anyxml_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.anyxml_stmt(&anyxml_stmt_built)?;
        self.push(ASTType::AnyxmlStmt(anyxml_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 190:
    ///
    /// `AnyxmlStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let anyxml_stmt_suffix_0_built = AnyxmlStmtSuffixSemicolon {};
        let anyxml_stmt_suffix_0_built = AnyxmlStmtSuffix::Semicolon(anyxml_stmt_suffix_0_built);
        self.push(
            ASTType::AnyxmlStmtSuffix(anyxml_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 191:
    ///
    /// `AnyxmlStmtSuffix: LBrace^ /* Clipped */ AnyxmlStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _anyxml_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anyxml_stmt_list =
            pop_and_reverse_item!(self, anyxml_stmt_list, AnyxmlStmtList, context);
        self.pop(context);
        let anyxml_stmt_suffix_1_built =
            AnyxmlStmtSuffixLBraceAnyxmlStmtListRBrace { anyxml_stmt_list };
        let anyxml_stmt_suffix_1_built =
            AnyxmlStmtSuffix::LBraceAnyxmlStmtListRBrace(anyxml_stmt_suffix_1_built);
        self.push(
            ASTType::AnyxmlStmtSuffix(anyxml_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 192:
    ///
    /// `AnyxmlStmtList /* Vec<T>::Push */: AnyxmlStmtListGroup AnyxmlStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_0(
        &mut self,
        _anyxml_stmt_list_group: &ParseTreeType<'t>,
        _anyxml_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut anyxml_stmt_list = pop_item!(self, anyxml_stmt_list, AnyxmlStmtList, context);
        let anyxml_stmt_list_group =
            pop_item!(self, anyxml_stmt_list_group, AnyxmlStmtListGroup, context);
        let anyxml_stmt_list_0_built = AnyxmlStmtList {
            anyxml_stmt_list_group: Box::new(anyxml_stmt_list_group),
        };
        // Add an element to the vector
        anyxml_stmt_list.push(anyxml_stmt_list_0_built);
        self.push(ASTType::AnyxmlStmtList(anyxml_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 193:
    ///
    /// `AnyxmlStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let anyxml_stmt_list_group_0_built = AnyxmlStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let anyxml_stmt_list_group_0_built =
            AnyxmlStmtListGroup::WhenStmt(anyxml_stmt_list_group_0_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 194:
    ///
    /// `AnyxmlStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let anyxml_stmt_list_group_1_built = AnyxmlStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let anyxml_stmt_list_group_1_built =
            AnyxmlStmtListGroup::IfFeatureStmt(anyxml_stmt_list_group_1_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 195:
    ///
    /// `AnyxmlStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_2(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let anyxml_stmt_list_group_2_built = AnyxmlStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let anyxml_stmt_list_group_2_built =
            AnyxmlStmtListGroup::MustStmt(anyxml_stmt_list_group_2_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 196:
    ///
    /// `AnyxmlStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_3(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let anyxml_stmt_list_group_3_built = AnyxmlStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let anyxml_stmt_list_group_3_built =
            AnyxmlStmtListGroup::ConfigStmt(anyxml_stmt_list_group_3_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 197:
    ///
    /// `AnyxmlStmtListGroup: MandatoryStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_4(&mut self, _mandatory_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_stmt = pop_item!(self, mandatory_stmt, MandatoryStmt, context);
        let anyxml_stmt_list_group_4_built = AnyxmlStmtListGroupMandatoryStmt {
            mandatory_stmt: Box::new(mandatory_stmt),
        };
        let anyxml_stmt_list_group_4_built =
            AnyxmlStmtListGroup::MandatoryStmt(anyxml_stmt_list_group_4_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 198:
    ///
    /// `AnyxmlStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_5(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let anyxml_stmt_list_group_5_built = AnyxmlStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let anyxml_stmt_list_group_5_built =
            AnyxmlStmtListGroup::StatusStmt(anyxml_stmt_list_group_5_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 199:
    ///
    /// `AnyxmlStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_6(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let anyxml_stmt_list_group_6_built = AnyxmlStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let anyxml_stmt_list_group_6_built =
            AnyxmlStmtListGroup::DescriptionStmt(anyxml_stmt_list_group_6_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 200:
    ///
    /// `AnyxmlStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_group_7(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let anyxml_stmt_list_group_7_built = AnyxmlStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let anyxml_stmt_list_group_7_built =
            AnyxmlStmtListGroup::ReferenceStmt(anyxml_stmt_list_group_7_built);
        self.push(
            ASTType::AnyxmlStmtListGroup(anyxml_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 201:
    ///
    /// `AnyxmlStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn anyxml_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anyxml_stmt_list_1_built = Vec::new();
        self.push(ASTType::AnyxmlStmtList(anyxml_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 202:
    ///
    /// `ChoiceStmt: KwChoice^ /* Clipped */ IdentifierRefArgStr ChoiceStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt(
        &mut self,
        _kw_choice: &ParseTreeType<'t>,
        _identifier_ref_arg_str: &ParseTreeType<'t>,
        _choice_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let choice_stmt_suffix = pop_item!(self, choice_stmt_suffix, ChoiceStmtSuffix, context);
        let identifier_ref_arg_str =
            pop_item!(self, identifier_ref_arg_str, IdentifierRefArgStr, context);
        self.pop(context);
        let choice_stmt_built = ChoiceStmt {
            identifier_ref_arg_str: Box::new(identifier_ref_arg_str),
            choice_stmt_suffix: Box::new(choice_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.choice_stmt(&choice_stmt_built)?;
        self.push(ASTType::ChoiceStmt(choice_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 203:
    ///
    /// `ChoiceStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let choice_stmt_suffix_0_built = ChoiceStmtSuffixSemicolon {};
        let choice_stmt_suffix_0_built = ChoiceStmtSuffix::Semicolon(choice_stmt_suffix_0_built);
        self.push(
            ASTType::ChoiceStmtSuffix(choice_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 204:
    ///
    /// `ChoiceStmtSuffix: LBrace^ /* Clipped */ ChoiceStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _choice_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let choice_stmt_list =
            pop_and_reverse_item!(self, choice_stmt_list, ChoiceStmtList, context);
        self.pop(context);
        let choice_stmt_suffix_1_built = ChoiceStmtSuffixLBraceChoiceStmtListRBrace {
            choice_stmt_list,
            r_brace,
        };
        let choice_stmt_suffix_1_built =
            ChoiceStmtSuffix::LBraceChoiceStmtListRBrace(choice_stmt_suffix_1_built);
        self.push(
            ASTType::ChoiceStmtSuffix(choice_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 205:
    ///
    /// `ChoiceStmtList /* Vec<T>::Push */: ChoiceStmtListGroup ChoiceStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_0(
        &mut self,
        _choice_stmt_list_group: &ParseTreeType<'t>,
        _choice_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut choice_stmt_list = pop_item!(self, choice_stmt_list, ChoiceStmtList, context);
        let choice_stmt_list_group =
            pop_item!(self, choice_stmt_list_group, ChoiceStmtListGroup, context);
        let choice_stmt_list_0_built = ChoiceStmtList {
            choice_stmt_list_group: Box::new(choice_stmt_list_group),
        };
        // Add an element to the vector
        choice_stmt_list.push(choice_stmt_list_0_built);
        self.push(ASTType::ChoiceStmtList(choice_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 206:
    ///
    /// `ChoiceStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let choice_stmt_list_group_0_built = ChoiceStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let choice_stmt_list_group_0_built =
            ChoiceStmtListGroup::WhenStmt(choice_stmt_list_group_0_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 207:
    ///
    /// `ChoiceStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let choice_stmt_list_group_1_built = ChoiceStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let choice_stmt_list_group_1_built =
            ChoiceStmtListGroup::IfFeatureStmt(choice_stmt_list_group_1_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 208:
    ///
    /// `ChoiceStmtListGroup: DefaultStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_2(&mut self, _default_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt = pop_item!(self, default_stmt, DefaultStmt, context);
        let choice_stmt_list_group_2_built = ChoiceStmtListGroupDefaultStmt {
            default_stmt: Box::new(default_stmt),
        };
        let choice_stmt_list_group_2_built =
            ChoiceStmtListGroup::DefaultStmt(choice_stmt_list_group_2_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 209:
    ///
    /// `ChoiceStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_3(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let choice_stmt_list_group_3_built = ChoiceStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let choice_stmt_list_group_3_built =
            ChoiceStmtListGroup::ConfigStmt(choice_stmt_list_group_3_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 210:
    ///
    /// `ChoiceStmtListGroup: MandatoryStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_4(&mut self, _mandatory_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_stmt = pop_item!(self, mandatory_stmt, MandatoryStmt, context);
        let choice_stmt_list_group_4_built = ChoiceStmtListGroupMandatoryStmt {
            mandatory_stmt: Box::new(mandatory_stmt),
        };
        let choice_stmt_list_group_4_built =
            ChoiceStmtListGroup::MandatoryStmt(choice_stmt_list_group_4_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 211:
    ///
    /// `ChoiceStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_5(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let choice_stmt_list_group_5_built = ChoiceStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let choice_stmt_list_group_5_built =
            ChoiceStmtListGroup::StatusStmt(choice_stmt_list_group_5_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 212:
    ///
    /// `ChoiceStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_6(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let choice_stmt_list_group_6_built = ChoiceStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let choice_stmt_list_group_6_built =
            ChoiceStmtListGroup::DescriptionStmt(choice_stmt_list_group_6_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 213:
    ///
    /// `ChoiceStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_7(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let choice_stmt_list_group_7_built = ChoiceStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let choice_stmt_list_group_7_built =
            ChoiceStmtListGroup::ReferenceStmt(choice_stmt_list_group_7_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 214:
    ///
    /// `ChoiceStmtListGroup: ShortCaseStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_8(&mut self, _short_case_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let short_case_stmt = pop_item!(self, short_case_stmt, ShortCaseStmt, context);
        let choice_stmt_list_group_8_built = ChoiceStmtListGroupShortCaseStmt {
            short_case_stmt: Box::new(short_case_stmt),
        };
        let choice_stmt_list_group_8_built =
            ChoiceStmtListGroup::ShortCaseStmt(choice_stmt_list_group_8_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 215:
    ///
    /// `ChoiceStmtListGroup: CaseStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_group_9(&mut self, _case_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let case_stmt = pop_item!(self, case_stmt, CaseStmt, context);
        let choice_stmt_list_group_9_built = ChoiceStmtListGroupCaseStmt {
            case_stmt: Box::new(case_stmt),
        };
        let choice_stmt_list_group_9_built =
            ChoiceStmtListGroup::CaseStmt(choice_stmt_list_group_9_built);
        self.push(
            ASTType::ChoiceStmtListGroup(choice_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 216:
    ///
    /// `ChoiceStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn choice_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let choice_stmt_list_1_built = Vec::new();
        self.push(ASTType::ChoiceStmtList(choice_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 217:
    ///
    /// `ShortCaseStmt: ChoiceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_0(&mut self, _choice_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let choice_stmt = pop_item!(self, choice_stmt, ChoiceStmt, context);
        let short_case_stmt_0_built = ShortCaseStmtChoiceStmt {
            choice_stmt: Box::new(choice_stmt),
        };
        let short_case_stmt_0_built = ShortCaseStmt::ChoiceStmt(short_case_stmt_0_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_0_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_0_built), context);
        Ok(())
    }

    /// Semantic action for production 218:
    ///
    /// `ShortCaseStmt: ContainerStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_1(&mut self, _container_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let container_stmt = pop_item!(self, container_stmt, ContainerStmt, context);
        let short_case_stmt_1_built = ShortCaseStmtContainerStmt {
            container_stmt: Box::new(container_stmt),
        };
        let short_case_stmt_1_built = ShortCaseStmt::ContainerStmt(short_case_stmt_1_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_1_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_1_built), context);
        Ok(())
    }

    /// Semantic action for production 219:
    ///
    /// `ShortCaseStmt: LeafStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_2(&mut self, _leaf_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_stmt = pop_item!(self, leaf_stmt, LeafStmt, context);
        let short_case_stmt_2_built = ShortCaseStmtLeafStmt {
            leaf_stmt: Box::new(leaf_stmt),
        };
        let short_case_stmt_2_built = ShortCaseStmt::LeafStmt(short_case_stmt_2_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_2_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_2_built), context);
        Ok(())
    }

    /// Semantic action for production 220:
    ///
    /// `ShortCaseStmt: LeafListStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_3(&mut self, _leaf_list_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_list_stmt = pop_item!(self, leaf_list_stmt, LeafListStmt, context);
        let short_case_stmt_3_built = ShortCaseStmtLeafListStmt {
            leaf_list_stmt: Box::new(leaf_list_stmt),
        };
        let short_case_stmt_3_built = ShortCaseStmt::LeafListStmt(short_case_stmt_3_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_3_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_3_built), context);
        Ok(())
    }

    /// Semantic action for production 221:
    ///
    /// `ShortCaseStmt: ListStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_4(&mut self, _list_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let list_stmt = pop_item!(self, list_stmt, ListStmt, context);
        let short_case_stmt_4_built = ShortCaseStmtListStmt {
            list_stmt: Box::new(list_stmt),
        };
        let short_case_stmt_4_built = ShortCaseStmt::ListStmt(short_case_stmt_4_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_4_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_4_built), context);
        Ok(())
    }

    /// Semantic action for production 222:
    ///
    /// `ShortCaseStmt: AnydataStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_5(&mut self, _anydata_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anydata_stmt = pop_item!(self, anydata_stmt, AnydataStmt, context);
        let short_case_stmt_5_built = ShortCaseStmtAnydataStmt {
            anydata_stmt: Box::new(anydata_stmt),
        };
        let short_case_stmt_5_built = ShortCaseStmt::AnydataStmt(short_case_stmt_5_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_5_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_5_built), context);
        Ok(())
    }

    /// Semantic action for production 223:
    ///
    /// `ShortCaseStmt: AnyxmlStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn short_case_stmt_6(&mut self, _anyxml_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anyxml_stmt = pop_item!(self, anyxml_stmt, AnyxmlStmt, context);
        let short_case_stmt_6_built = ShortCaseStmtAnyxmlStmt {
            anyxml_stmt: Box::new(anyxml_stmt),
        };
        let short_case_stmt_6_built = ShortCaseStmt::AnyxmlStmt(short_case_stmt_6_built);
        // Calling user action here
        self.user_grammar
            .short_case_stmt(&short_case_stmt_6_built)?;
        self.push(ASTType::ShortCaseStmt(short_case_stmt_6_built), context);
        Ok(())
    }

    /// Semantic action for production 224:
    ///
    /// `AnydataStmt: KwAnydata^ /* Clipped */ IdentifierArgStr AnydataStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt(
        &mut self,
        _kw_anydata: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _anydata_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anydata_stmt_suffix = pop_item!(self, anydata_stmt_suffix, AnydataStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let anydata_stmt_built = AnydataStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            anydata_stmt_suffix: Box::new(anydata_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.anydata_stmt(&anydata_stmt_built)?;
        self.push(ASTType::AnydataStmt(anydata_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 225:
    ///
    /// `AnydataStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let anydata_stmt_suffix_0_built = AnydataStmtSuffixSemicolon {};
        let anydata_stmt_suffix_0_built = AnydataStmtSuffix::Semicolon(anydata_stmt_suffix_0_built);
        self.push(
            ASTType::AnydataStmtSuffix(anydata_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 226:
    ///
    /// `AnydataStmtSuffix: LBrace^ /* Clipped */ AnydataStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _anydata_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anydata_stmt_list =
            pop_and_reverse_item!(self, anydata_stmt_list, AnydataStmtList, context);
        self.pop(context);
        let anydata_stmt_suffix_1_built =
            AnydataStmtSuffixLBraceAnydataStmtListRBrace { anydata_stmt_list };
        let anydata_stmt_suffix_1_built =
            AnydataStmtSuffix::LBraceAnydataStmtListRBrace(anydata_stmt_suffix_1_built);
        self.push(
            ASTType::AnydataStmtSuffix(anydata_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 227:
    ///
    /// `AnydataStmtList /* Vec<T>::Push */: AnydataStmtListGroup AnydataStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_0(
        &mut self,
        _anydata_stmt_list_group: &ParseTreeType<'t>,
        _anydata_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut anydata_stmt_list = pop_item!(self, anydata_stmt_list, AnydataStmtList, context);
        let anydata_stmt_list_group =
            pop_item!(self, anydata_stmt_list_group, AnydataStmtListGroup, context);
        let anydata_stmt_list_0_built = AnydataStmtList {
            anydata_stmt_list_group: Box::new(anydata_stmt_list_group),
        };
        // Add an element to the vector
        anydata_stmt_list.push(anydata_stmt_list_0_built);
        self.push(ASTType::AnydataStmtList(anydata_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 228:
    ///
    /// `AnydataStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let anydata_stmt_list_group_0_built = AnydataStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let anydata_stmt_list_group_0_built =
            AnydataStmtListGroup::WhenStmt(anydata_stmt_list_group_0_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 229:
    ///
    /// `AnydataStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let anydata_stmt_list_group_1_built = AnydataStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let anydata_stmt_list_group_1_built =
            AnydataStmtListGroup::IfFeatureStmt(anydata_stmt_list_group_1_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 230:
    ///
    /// `AnydataStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_2(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let anydata_stmt_list_group_2_built = AnydataStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let anydata_stmt_list_group_2_built =
            AnydataStmtListGroup::MustStmt(anydata_stmt_list_group_2_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 231:
    ///
    /// `AnydataStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_3(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let anydata_stmt_list_group_3_built = AnydataStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let anydata_stmt_list_group_3_built =
            AnydataStmtListGroup::ConfigStmt(anydata_stmt_list_group_3_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 232:
    ///
    /// `AnydataStmtListGroup: MandatoryStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_4(&mut self, _mandatory_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_stmt = pop_item!(self, mandatory_stmt, MandatoryStmt, context);
        let anydata_stmt_list_group_4_built = AnydataStmtListGroupMandatoryStmt {
            mandatory_stmt: Box::new(mandatory_stmt),
        };
        let anydata_stmt_list_group_4_built =
            AnydataStmtListGroup::MandatoryStmt(anydata_stmt_list_group_4_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 233:
    ///
    /// `AnydataStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_5(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let anydata_stmt_list_group_5_built = AnydataStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let anydata_stmt_list_group_5_built =
            AnydataStmtListGroup::StatusStmt(anydata_stmt_list_group_5_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 234:
    ///
    /// `AnydataStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_6(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let anydata_stmt_list_group_6_built = AnydataStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let anydata_stmt_list_group_6_built =
            AnydataStmtListGroup::DescriptionStmt(anydata_stmt_list_group_6_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 235:
    ///
    /// `AnydataStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_group_7(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let anydata_stmt_list_group_7_built = AnydataStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let anydata_stmt_list_group_7_built =
            AnydataStmtListGroup::ReferenceStmt(anydata_stmt_list_group_7_built);
        self.push(
            ASTType::AnydataStmtListGroup(anydata_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 236:
    ///
    /// `AnydataStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn anydata_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let anydata_stmt_list_1_built = Vec::new();
        self.push(ASTType::AnydataStmtList(anydata_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 237:
    ///
    /// `CaseStmt: KwCase^ /* Clipped */ IdentifierArgStr CaseStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt(
        &mut self,
        _kw_case: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _case_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let case_stmt_suffix = pop_item!(self, case_stmt_suffix, CaseStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let case_stmt_built = CaseStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            case_stmt_suffix: Box::new(case_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.case_stmt(&case_stmt_built)?;
        self.push(ASTType::CaseStmt(case_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 238:
    ///
    /// `CaseStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let case_stmt_suffix_0_built = CaseStmtSuffixSemicolon {};
        let case_stmt_suffix_0_built = CaseStmtSuffix::Semicolon(case_stmt_suffix_0_built);
        self.push(ASTType::CaseStmtSuffix(case_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 239:
    ///
    /// `CaseStmtSuffix: LBrace^ /* Clipped */ CaseStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _case_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let case_stmt_list = pop_and_reverse_item!(self, case_stmt_list, CaseStmtList, context);
        self.pop(context);
        let case_stmt_suffix_1_built = CaseStmtSuffixLBraceCaseStmtListRBrace { case_stmt_list };
        let case_stmt_suffix_1_built =
            CaseStmtSuffix::LBraceCaseStmtListRBrace(case_stmt_suffix_1_built);
        self.push(ASTType::CaseStmtSuffix(case_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 240:
    ///
    /// `CaseStmtList /* Vec<T>::Push */: CaseStmtListGroup CaseStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_0(
        &mut self,
        _case_stmt_list_group: &ParseTreeType<'t>,
        _case_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut case_stmt_list = pop_item!(self, case_stmt_list, CaseStmtList, context);
        let case_stmt_list_group =
            pop_item!(self, case_stmt_list_group, CaseStmtListGroup, context);
        let case_stmt_list_0_built = CaseStmtList {
            case_stmt_list_group: Box::new(case_stmt_list_group),
        };
        // Add an element to the vector
        case_stmt_list.push(case_stmt_list_0_built);
        self.push(ASTType::CaseStmtList(case_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 241:
    ///
    /// `CaseStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let case_stmt_list_group_0_built = CaseStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let case_stmt_list_group_0_built =
            CaseStmtListGroup::WhenStmt(case_stmt_list_group_0_built);
        self.push(
            ASTType::CaseStmtListGroup(case_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 242:
    ///
    /// `CaseStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let case_stmt_list_group_1_built = CaseStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let case_stmt_list_group_1_built =
            CaseStmtListGroup::IfFeatureStmt(case_stmt_list_group_1_built);
        self.push(
            ASTType::CaseStmtListGroup(case_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 243:
    ///
    /// `CaseStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_group_2(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let case_stmt_list_group_2_built = CaseStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let case_stmt_list_group_2_built =
            CaseStmtListGroup::DataDefStmt(case_stmt_list_group_2_built);
        self.push(
            ASTType::CaseStmtListGroup(case_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 244:
    ///
    /// `CaseStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_group_3(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let case_stmt_list_group_3_built = CaseStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let case_stmt_list_group_3_built =
            CaseStmtListGroup::DescriptionStmt(case_stmt_list_group_3_built);
        self.push(
            ASTType::CaseStmtListGroup(case_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 245:
    ///
    /// `CaseStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_group_4(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let case_stmt_list_group_4_built = CaseStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let case_stmt_list_group_4_built =
            CaseStmtListGroup::ReferenceStmt(case_stmt_list_group_4_built);
        self.push(
            ASTType::CaseStmtListGroup(case_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 246:
    ///
    /// `CaseStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn case_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let case_stmt_list_1_built = Vec::new();
        self.push(ASTType::CaseStmtList(case_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 247:
    ///
    /// `StatusStmt: KwStatus^ /* Clipped */ StatusArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn status_stmt(
        &mut self,
        _kw_status: &ParseTreeType<'t>,
        _status_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let status_arg_str = pop_item!(self, status_arg_str, StatusArgStr, context);
        self.pop(context);
        let status_stmt_built = StatusStmt {
            status_arg_str: Box::new(status_arg_str),
        };
        // Calling user action here
        self.user_grammar.status_stmt(&status_stmt_built)?;
        self.push(ASTType::StatusStmt(status_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 248:
    ///
    /// `StatusArgStr: StatusArg;`
    ///
    #[parol_runtime::function_name::named]
    fn status_arg_str_0(&mut self, _status_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_arg = pop_item!(self, status_arg, StatusArg, context);
        let status_arg_str_0_built = StatusArgStrStatusArg {
            status_arg: Box::new(status_arg),
        };
        let status_arg_str_0_built = StatusArgStr::StatusArg(status_arg_str_0_built);
        // Calling user action here
        self.user_grammar.status_arg_str(&status_arg_str_0_built)?;
        self.push(ASTType::StatusArgStr(status_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 249:
    ///
    /// `StatusArgStr: <Status>'"'^ /* Clipped */ StatusArg <Status>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn status_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _status_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_arg = pop_item!(self, status_arg, StatusArg, context);
        let status_arg_str_1_built = StatusArgStrDoubleQuotationStatusArgDoubleQuotation {
            status_arg: Box::new(status_arg),
        };
        let status_arg_str_1_built =
            StatusArgStr::DoubleQuotationStatusArgDoubleQuotation(status_arg_str_1_built);
        // Calling user action here
        self.user_grammar.status_arg_str(&status_arg_str_1_built)?;
        self.push(ASTType::StatusArgStr(status_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 250:
    ///
    /// `StatusArg: <Status>/current|obsolete|deprecated/;`
    ///
    #[parol_runtime::function_name::named]
    fn status_arg(&mut self, status_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_arg = status_arg.token()?.clone();
        let status_arg_built = StatusArg { status_arg };
        // Calling user action here
        self.user_grammar.status_arg(&status_arg_built)?;
        self.push(ASTType::StatusArg(status_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 251:
    ///
    /// `ContainerStmt: KwContainer^ /* Clipped */ IdentifierArgStr ContainerStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt(
        &mut self,
        _kw_container: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _container_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let container_stmt_suffix =
            pop_item!(self, container_stmt_suffix, ContainerStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let container_stmt_built = ContainerStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            container_stmt_suffix: Box::new(container_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.container_stmt(&container_stmt_built)?;
        self.push(ASTType::ContainerStmt(container_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 252:
    ///
    /// `ContainerStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let container_stmt_suffix_0_built = ContainerStmtSuffixSemicolon {};
        let container_stmt_suffix_0_built =
            ContainerStmtSuffix::Semicolon(container_stmt_suffix_0_built);
        self.push(
            ASTType::ContainerStmtSuffix(container_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 253:
    ///
    /// `ContainerStmtSuffix: LBrace^ /* Clipped */ ContainerStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _container_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let container_stmt_list =
            pop_and_reverse_item!(self, container_stmt_list, ContainerStmtList, context);
        self.pop(context);
        let container_stmt_suffix_1_built = ContainerStmtSuffixLBraceContainerStmtListRBrace {
            container_stmt_list,
        };
        let container_stmt_suffix_1_built =
            ContainerStmtSuffix::LBraceContainerStmtListRBrace(container_stmt_suffix_1_built);
        self.push(
            ASTType::ContainerStmtSuffix(container_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 254:
    ///
    /// `ContainerStmtList /* Vec<T>::Push */: ContainerStmtListGroup ContainerStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_0(
        &mut self,
        _container_stmt_list_group: &ParseTreeType<'t>,
        _container_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut container_stmt_list =
            pop_item!(self, container_stmt_list, ContainerStmtList, context);
        let container_stmt_list_group = pop_item!(
            self,
            container_stmt_list_group,
            ContainerStmtListGroup,
            context
        );
        let container_stmt_list_0_built = ContainerStmtList {
            container_stmt_list_group: Box::new(container_stmt_list_group),
        };
        // Add an element to the vector
        container_stmt_list.push(container_stmt_list_0_built);
        self.push(ASTType::ContainerStmtList(container_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 255:
    ///
    /// `ContainerStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let container_stmt_list_group_0_built = ContainerStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let container_stmt_list_group_0_built =
            ContainerStmtListGroup::WhenStmt(container_stmt_list_group_0_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 256:
    ///
    /// `ContainerStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let container_stmt_list_group_1_built = ContainerStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let container_stmt_list_group_1_built =
            ContainerStmtListGroup::IfFeatureStmt(container_stmt_list_group_1_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 257:
    ///
    /// `ContainerStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_2(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let container_stmt_list_group_2_built = ContainerStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let container_stmt_list_group_2_built =
            ContainerStmtListGroup::MustStmt(container_stmt_list_group_2_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 258:
    ///
    /// `ContainerStmtListGroup: PresenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_3(&mut self, _presence_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let presence_stmt = pop_item!(self, presence_stmt, PresenceStmt, context);
        let container_stmt_list_group_3_built = ContainerStmtListGroupPresenceStmt {
            presence_stmt: Box::new(presence_stmt),
        };
        let container_stmt_list_group_3_built =
            ContainerStmtListGroup::PresenceStmt(container_stmt_list_group_3_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 259:
    ///
    /// `ContainerStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_4(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let container_stmt_list_group_4_built = ContainerStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let container_stmt_list_group_4_built =
            ContainerStmtListGroup::ConfigStmt(container_stmt_list_group_4_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 260:
    ///
    /// `ContainerStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_5(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let container_stmt_list_group_5_built = ContainerStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let container_stmt_list_group_5_built =
            ContainerStmtListGroup::StatusStmt(container_stmt_list_group_5_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 261:
    ///
    /// `ContainerStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_6(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let container_stmt_list_group_6_built = ContainerStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let container_stmt_list_group_6_built =
            ContainerStmtListGroup::DescriptionStmt(container_stmt_list_group_6_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 262:
    ///
    /// `ContainerStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_7(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let container_stmt_list_group_7_built = ContainerStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let container_stmt_list_group_7_built =
            ContainerStmtListGroup::ReferenceStmt(container_stmt_list_group_7_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 263:
    ///
    /// `ContainerStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_8(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let container_stmt_list_group_8_built = ContainerStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let container_stmt_list_group_8_built =
            ContainerStmtListGroup::DataDefStmt(container_stmt_list_group_8_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 264:
    ///
    /// `ContainerStmtListGroup: ActionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_9(&mut self, _action_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt = pop_item!(self, action_stmt, ActionStmt, context);
        let container_stmt_list_group_9_built = ContainerStmtListGroupActionStmt {
            action_stmt: Box::new(action_stmt),
        };
        let container_stmt_list_group_9_built =
            ContainerStmtListGroup::ActionStmt(container_stmt_list_group_9_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 265:
    ///
    /// `ContainerStmtListGroup: NotificationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_10(
        &mut self,
        _notification_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt = pop_item!(self, notification_stmt, NotificationStmt, context);
        let container_stmt_list_group_10_built = ContainerStmtListGroupNotificationStmt {
            notification_stmt: Box::new(notification_stmt),
        };
        let container_stmt_list_group_10_built =
            ContainerStmtListGroup::NotificationStmt(container_stmt_list_group_10_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_10_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 266:
    ///
    /// `ContainerStmtListGroup: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_group_11(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let container_stmt_list_group_11_built = ContainerStmtListGroupUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let container_stmt_list_group_11_built =
            ContainerStmtListGroup::UnknownStmt(container_stmt_list_group_11_built);
        self.push(
            ASTType::ContainerStmtListGroup(container_stmt_list_group_11_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 267:
    ///
    /// `ContainerStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn container_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let container_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::ContainerStmtList(container_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 268:
    ///
    /// `ActionStmt: KwAction^ /* Clipped */ IdentifierArgStr ActionStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt(
        &mut self,
        _kw_action: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _action_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt_suffix = pop_item!(self, action_stmt_suffix, ActionStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let action_stmt_built = ActionStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            action_stmt_suffix: Box::new(action_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.action_stmt(&action_stmt_built)?;
        self.push(ASTType::ActionStmt(action_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 269:
    ///
    /// `ActionStmtSuffix: Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let action_stmt_suffix_0_built = ActionStmtSuffixSemicolon {
            semicolon: Box::new(semicolon),
        };
        let action_stmt_suffix_0_built = ActionStmtSuffix::Semicolon(action_stmt_suffix_0_built);
        self.push(
            ASTType::ActionStmtSuffix(action_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 270:
    ///
    /// `ActionStmtSuffix: LBrace^ /* Clipped */ ActionStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _action_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let action_stmt_list =
            pop_and_reverse_item!(self, action_stmt_list, ActionStmtList, context);
        self.pop(context);
        let action_stmt_suffix_1_built = ActionStmtSuffixLBraceActionStmtListRBrace {
            action_stmt_list,
            r_brace,
        };
        let action_stmt_suffix_1_built =
            ActionStmtSuffix::LBraceActionStmtListRBrace(action_stmt_suffix_1_built);
        self.push(
            ASTType::ActionStmtSuffix(action_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 271:
    ///
    /// `ActionStmtList /* Vec<T>::Push */: ActionStmtListGroup ActionStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_0(
        &mut self,
        _action_stmt_list_group: &ParseTreeType<'t>,
        _action_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut action_stmt_list = pop_item!(self, action_stmt_list, ActionStmtList, context);
        let action_stmt_list_group =
            pop_item!(self, action_stmt_list_group, ActionStmtListGroup, context);
        let action_stmt_list_0_built = ActionStmtList {
            action_stmt_list_group: Box::new(action_stmt_list_group),
        };
        // Add an element to the vector
        action_stmt_list.push(action_stmt_list_0_built);
        self.push(ASTType::ActionStmtList(action_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 272:
    ///
    /// `ActionStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let action_stmt_list_group_0_built = ActionStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let action_stmt_list_group_0_built =
            ActionStmtListGroup::IfFeatureStmt(action_stmt_list_group_0_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 273:
    ///
    /// `ActionStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_1(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let action_stmt_list_group_1_built = ActionStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let action_stmt_list_group_1_built =
            ActionStmtListGroup::StatusStmt(action_stmt_list_group_1_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 274:
    ///
    /// `ActionStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let action_stmt_list_group_2_built = ActionStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let action_stmt_list_group_2_built =
            ActionStmtListGroup::DescriptionStmt(action_stmt_list_group_2_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 275:
    ///
    /// `ActionStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let action_stmt_list_group_3_built = ActionStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let action_stmt_list_group_3_built =
            ActionStmtListGroup::ReferenceStmt(action_stmt_list_group_3_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 276:
    ///
    /// `ActionStmtListGroup: InputStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_4(&mut self, _input_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let input_stmt = pop_item!(self, input_stmt, InputStmt, context);
        let action_stmt_list_group_4_built = ActionStmtListGroupInputStmt {
            input_stmt: Box::new(input_stmt),
        };
        let action_stmt_list_group_4_built =
            ActionStmtListGroup::InputStmt(action_stmt_list_group_4_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 277:
    ///
    /// `ActionStmtListGroup: OutputStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_group_5(&mut self, _output_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let output_stmt = pop_item!(self, output_stmt, OutputStmt, context);
        let action_stmt_list_group_5_built = ActionStmtListGroupOutputStmt {
            output_stmt: Box::new(output_stmt),
        };
        let action_stmt_list_group_5_built =
            ActionStmtListGroup::OutputStmt(action_stmt_list_group_5_built);
        self.push(
            ASTType::ActionStmtListGroup(action_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 278:
    ///
    /// `ActionStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn action_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt_list_1_built = Vec::new();
        self.push(ASTType::ActionStmtList(action_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 279:
    ///
    /// `InputStmt: 'input' LBrace^ /* Clipped */ InputStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn input_stmt(
        &mut self,
        input: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _input_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let input = input.token()?.clone();
        let r_brace = r_brace.token()?.clone();
        let input_stmt_list = pop_and_reverse_item!(self, input_stmt_list, InputStmtList, context);
        self.pop(context);
        let input_stmt_built = InputStmt {
            input,
            input_stmt_list,
            r_brace,
        };
        // Calling user action here
        self.user_grammar.input_stmt(&input_stmt_built)?;
        self.push(ASTType::InputStmt(input_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 280:
    ///
    /// `InputStmtList /* Vec<T>::Push */: DataDefStmt InputStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn input_stmt_list_0(
        &mut self,
        _data_def_stmt: &ParseTreeType<'t>,
        _input_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut input_stmt_list = pop_item!(self, input_stmt_list, InputStmtList, context);
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let input_stmt_list_0_built = InputStmtList {
            data_def_stmt: Box::new(data_def_stmt),
        };
        // Add an element to the vector
        input_stmt_list.push(input_stmt_list_0_built);
        self.push(ASTType::InputStmtList(input_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 281:
    ///
    /// `InputStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn input_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let input_stmt_list_1_built = Vec::new();
        self.push(ASTType::InputStmtList(input_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 282:
    ///
    /// `OutputStmt: 'output' LBrace^ /* Clipped */ OutputStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn output_stmt(
        &mut self,
        output: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _output_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let output = output.token()?.clone();
        let r_brace = r_brace.token()?.clone();
        let output_stmt_list =
            pop_and_reverse_item!(self, output_stmt_list, OutputStmtList, context);
        self.pop(context);
        let output_stmt_built = OutputStmt {
            output,
            output_stmt_list,
            r_brace,
        };
        // Calling user action here
        self.user_grammar.output_stmt(&output_stmt_built)?;
        self.push(ASTType::OutputStmt(output_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 283:
    ///
    /// `OutputStmtList /* Vec<T>::Push */: DataDefStmt OutputStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn output_stmt_list_0(
        &mut self,
        _data_def_stmt: &ParseTreeType<'t>,
        _output_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut output_stmt_list = pop_item!(self, output_stmt_list, OutputStmtList, context);
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let output_stmt_list_0_built = OutputStmtList {
            data_def_stmt: Box::new(data_def_stmt),
        };
        // Add an element to the vector
        output_stmt_list.push(output_stmt_list_0_built);
        self.push(ASTType::OutputStmtList(output_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 284:
    ///
    /// `OutputStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn output_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let output_stmt_list_1_built = Vec::new();
        self.push(ASTType::OutputStmtList(output_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 285:
    ///
    /// `NotificationStmt: KwNotification^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ NotificationStmtList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt(
        &mut self,
        _kw_notification: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _notification_stmt_list: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_brace = r_brace.token()?.clone();
        let notification_stmt_list =
            pop_and_reverse_item!(self, notification_stmt_list, NotificationStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let notification_stmt_built = NotificationStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            notification_stmt_list,
            r_brace,
        };
        // Calling user action here
        self.user_grammar
            .notification_stmt(&notification_stmt_built)?;
        self.push(ASTType::NotificationStmt(notification_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 286:
    ///
    /// `NotificationStmtList /* Vec<T>::Push */: NotificationStmtListGroup NotificationStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_0(
        &mut self,
        _notification_stmt_list_group: &ParseTreeType<'t>,
        _notification_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut notification_stmt_list =
            pop_item!(self, notification_stmt_list, NotificationStmtList, context);
        let notification_stmt_list_group = pop_item!(
            self,
            notification_stmt_list_group,
            NotificationStmtListGroup,
            context
        );
        let notification_stmt_list_0_built = NotificationStmtList {
            notification_stmt_list_group: Box::new(notification_stmt_list_group),
        };
        // Add an element to the vector
        notification_stmt_list.push(notification_stmt_list_0_built);
        self.push(
            ASTType::NotificationStmtList(notification_stmt_list),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 287:
    ///
    /// `NotificationStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_0(
        &mut self,
        _if_feature_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let notification_stmt_list_group_0_built = NotificationStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let notification_stmt_list_group_0_built =
            NotificationStmtListGroup::IfFeatureStmt(notification_stmt_list_group_0_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 288:
    ///
    /// `NotificationStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_1(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let notification_stmt_list_group_1_built = NotificationStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let notification_stmt_list_group_1_built =
            NotificationStmtListGroup::MustStmt(notification_stmt_list_group_1_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 289:
    ///
    /// `NotificationStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_2(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let notification_stmt_list_group_2_built = NotificationStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let notification_stmt_list_group_2_built =
            NotificationStmtListGroup::StatusStmt(notification_stmt_list_group_2_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 290:
    ///
    /// `NotificationStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_3(
        &mut self,
        _description_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let notification_stmt_list_group_3_built = NotificationStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let notification_stmt_list_group_3_built =
            NotificationStmtListGroup::DescriptionStmt(notification_stmt_list_group_3_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 291:
    ///
    /// `NotificationStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_4(
        &mut self,
        _reference_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let notification_stmt_list_group_4_built = NotificationStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let notification_stmt_list_group_4_built =
            NotificationStmtListGroup::ReferenceStmt(notification_stmt_list_group_4_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 292:
    ///
    /// `NotificationStmtListGroup: TypedefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_5(&mut self, _typedef_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let typedef_stmt = pop_item!(self, typedef_stmt, TypedefStmt, context);
        let notification_stmt_list_group_5_built = NotificationStmtListGroupTypedefStmt {
            typedef_stmt: Box::new(typedef_stmt),
        };
        let notification_stmt_list_group_5_built =
            NotificationStmtListGroup::TypedefStmt(notification_stmt_list_group_5_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 293:
    ///
    /// `NotificationStmtListGroup: GroupingStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_6(&mut self, _grouping_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grouping_stmt = pop_item!(self, grouping_stmt, GroupingStmt, context);
        let notification_stmt_list_group_6_built = NotificationStmtListGroupGroupingStmt {
            grouping_stmt: Box::new(grouping_stmt),
        };
        let notification_stmt_list_group_6_built =
            NotificationStmtListGroup::GroupingStmt(notification_stmt_list_group_6_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 294:
    ///
    /// `NotificationStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_group_7(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let notification_stmt_list_group_7_built = NotificationStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let notification_stmt_list_group_7_built =
            NotificationStmtListGroup::DataDefStmt(notification_stmt_list_group_7_built);
        self.push(
            ASTType::NotificationStmtListGroup(notification_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 295:
    ///
    /// `NotificationStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn notification_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::NotificationStmtList(notification_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 296:
    ///
    /// `IfFeatureStmt: KwIfFeature^ /* Clipped */ IfFeatureExprStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_stmt(
        &mut self,
        _kw_if_feature: &ParseTreeType<'t>,
        _if_feature_expr_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let if_feature_expr_str = pop_item!(self, if_feature_expr_str, IfFeatureExprStr, context);
        self.pop(context);
        let if_feature_stmt_built = IfFeatureStmt {
            if_feature_expr_str: Box::new(if_feature_expr_str),
        };
        // Calling user action here
        self.user_grammar.if_feature_stmt(&if_feature_stmt_built)?;
        self.push(ASTType::IfFeatureStmt(if_feature_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 297:
    ///
    /// `IfFeatureExprStr: IfFeatureExpr;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_expr_str(&mut self, _if_feature_expr: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_expr = pop_item!(self, if_feature_expr, IfFeatureExpr, context);
        let if_feature_expr_str_built = IfFeatureExprStr {
            if_feature_expr: Box::new(if_feature_expr),
        };
        // Calling user action here
        self.user_grammar
            .if_feature_expr_str(&if_feature_expr_str_built)?;
        self.push(
            ASTType::IfFeatureExprStr(if_feature_expr_str_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 298:
    ///
    /// `IfFeatureExpr: IfFeatureTerm IfFeatureExprOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_expr(
        &mut self,
        _if_feature_term: &ParseTreeType<'t>,
        _if_feature_expr_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_expr_opt = pop_item!(self, if_feature_expr_opt, IfFeatureExprOpt, context);
        let if_feature_term = pop_item!(self, if_feature_term, IfFeatureTerm, context);
        let if_feature_expr_built = IfFeatureExpr {
            if_feature_term: Box::new(if_feature_term),
            if_feature_expr_opt,
        };
        // Calling user action here
        self.user_grammar.if_feature_expr(&if_feature_expr_built)?;
        self.push(ASTType::IfFeatureExpr(if_feature_expr_built), context);
        Ok(())
    }

    /// Semantic action for production 299:
    ///
    /// `IfFeatureExprOpt /* Option<T>::Some */: <IfFeature>'or' IfFeatureExpr;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_expr_opt_0(
        &mut self,
        or: &ParseTreeType<'t>,
        _if_feature_expr: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let or = or.token()?.clone();
        let if_feature_expr = pop_item!(self, if_feature_expr, IfFeatureExpr, context);
        let if_feature_expr_opt_0_built = IfFeatureExprOpt {
            or,
            if_feature_expr: Box::new(if_feature_expr),
        };
        self.push(
            ASTType::IfFeatureExprOpt(Some(if_feature_expr_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 300:
    ///
    /// `IfFeatureExprOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_expr_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::IfFeatureExprOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 301:
    ///
    /// `IfFeatureTerm: IfFeatureFactor IfFeatureTermOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_term(
        &mut self,
        _if_feature_factor: &ParseTreeType<'t>,
        _if_feature_term_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_term_opt = pop_item!(self, if_feature_term_opt, IfFeatureTermOpt, context);
        let if_feature_factor = pop_item!(self, if_feature_factor, IfFeatureFactor, context);
        let if_feature_term_built = IfFeatureTerm {
            if_feature_factor: Box::new(if_feature_factor),
            if_feature_term_opt,
        };
        // Calling user action here
        self.user_grammar.if_feature_term(&if_feature_term_built)?;
        self.push(ASTType::IfFeatureTerm(if_feature_term_built), context);
        Ok(())
    }

    /// Semantic action for production 302:
    ///
    /// `IfFeatureTermOpt /* Option<T>::Some */: <IfFeature>'and' IfFeatureTerm;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_term_opt_0(
        &mut self,
        and: &ParseTreeType<'t>,
        _if_feature_term: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let and = and.token()?.clone();
        let if_feature_term = pop_item!(self, if_feature_term, IfFeatureTerm, context);
        let if_feature_term_opt_0_built = IfFeatureTermOpt {
            and,
            if_feature_term: Box::new(if_feature_term),
        };
        self.push(
            ASTType::IfFeatureTermOpt(Some(if_feature_term_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 303:
    ///
    /// `IfFeatureTermOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_term_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::IfFeatureTermOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 304:
    ///
    /// `IfFeatureFactor: <IfFeature>'not' IfFeatureFactor;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_factor_0(
        &mut self,
        not: &ParseTreeType<'t>,
        _if_feature_factor: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let not = not.token()?.clone();
        let if_feature_factor = pop_item!(self, if_feature_factor, IfFeatureFactor, context);
        let if_feature_factor_0_built = IfFeatureFactorNotIfFeatureFactor {
            not,
            if_feature_factor: Box::new(if_feature_factor),
        };
        let if_feature_factor_0_built =
            IfFeatureFactor::NotIfFeatureFactor(if_feature_factor_0_built);
        // Calling user action here
        self.user_grammar
            .if_feature_factor(&if_feature_factor_0_built)?;
        self.push(ASTType::IfFeatureFactor(if_feature_factor_0_built), context);
        Ok(())
    }

    /// Semantic action for production 305:
    ///
    /// `IfFeatureFactor: <IfFeature>'(' IfFeatureExpr <IfFeature>')';`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_factor_1(
        &mut self,
        l_paren: &ParseTreeType<'t>,
        _if_feature_expr: &ParseTreeType<'t>,
        r_paren: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_paren = l_paren.token()?.clone();
        let r_paren = r_paren.token()?.clone();
        let if_feature_expr = pop_item!(self, if_feature_expr, IfFeatureExpr, context);
        let if_feature_factor_1_built = IfFeatureFactorLParenIfFeatureExprRParen {
            l_paren,
            if_feature_expr: Box::new(if_feature_expr),
            r_paren,
        };
        let if_feature_factor_1_built =
            IfFeatureFactor::LParenIfFeatureExprRParen(if_feature_factor_1_built);
        // Calling user action here
        self.user_grammar
            .if_feature_factor(&if_feature_factor_1_built)?;
        self.push(ASTType::IfFeatureFactor(if_feature_factor_1_built), context);
        Ok(())
    }

    /// Semantic action for production 306:
    ///
    /// `IfFeatureFactor: Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_factor_2(&mut self, _identifier: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let if_feature_factor_2_built = IfFeatureFactorIdentifier {
            identifier: Box::new(identifier),
        };
        let if_feature_factor_2_built = IfFeatureFactor::Identifier(if_feature_factor_2_built);
        // Calling user action here
        self.user_grammar
            .if_feature_factor(&if_feature_factor_2_built)?;
        self.push(ASTType::IfFeatureFactor(if_feature_factor_2_built), context);
        Ok(())
    }

    /// Semantic action for production 307:
    ///
    /// `IfFeatureFactor: <IfFeature>'"' Identifier <IfFeature>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn if_feature_factor_3(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let identifier = pop_item!(self, identifier, Identifier, context);
        let if_feature_factor_3_built = IfFeatureFactorDoubleQuotationIdentifierDoubleQuotation {
            double_quotation,
            identifier: Box::new(identifier),
            double_quotation0,
        };
        let if_feature_factor_3_built =
            IfFeatureFactor::DoubleQuotationIdentifierDoubleQuotation(if_feature_factor_3_built);
        // Calling user action here
        self.user_grammar
            .if_feature_factor(&if_feature_factor_3_built)?;
        self.push(ASTType::IfFeatureFactor(if_feature_factor_3_built), context);
        Ok(())
    }

    /// Semantic action for production 308:
    ///
    /// `PresenceStmt: 'presence'^ /* Clipped */ Ystring Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn presence_stmt(
        &mut self,
        _presence: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let presence_stmt_built = PresenceStmt {
            ystring: Box::new(ystring),
        };
        // Calling user action here
        self.user_grammar.presence_stmt(&presence_stmt_built)?;
        self.push(ASTType::PresenceStmt(presence_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 309:
    ///
    /// `UsesStmt: KwUses^ /* Clipped */ IdentifierRefArgStr UsesStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt(
        &mut self,
        _kw_uses: &ParseTreeType<'t>,
        _identifier_ref_arg_str: &ParseTreeType<'t>,
        _uses_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uses_stmt_suffix = pop_item!(self, uses_stmt_suffix, UsesStmtSuffix, context);
        let identifier_ref_arg_str =
            pop_item!(self, identifier_ref_arg_str, IdentifierRefArgStr, context);
        self.pop(context);
        let uses_stmt_built = UsesStmt {
            identifier_ref_arg_str: Box::new(identifier_ref_arg_str),
            uses_stmt_suffix: Box::new(uses_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.uses_stmt(&uses_stmt_built)?;
        self.push(ASTType::UsesStmt(uses_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 310:
    ///
    /// `UsesStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let uses_stmt_suffix_0_built = UsesStmtSuffixSemicolon {};
        let uses_stmt_suffix_0_built = UsesStmtSuffix::Semicolon(uses_stmt_suffix_0_built);
        self.push(ASTType::UsesStmtSuffix(uses_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 311:
    ///
    /// `UsesStmtSuffix: LBrace^ /* Clipped */ UsesStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _uses_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uses_stmt_list = pop_and_reverse_item!(self, uses_stmt_list, UsesStmtList, context);
        self.pop(context);
        let uses_stmt_suffix_1_built = UsesStmtSuffixLBraceUsesStmtListRBrace { uses_stmt_list };
        let uses_stmt_suffix_1_built =
            UsesStmtSuffix::LBraceUsesStmtListRBrace(uses_stmt_suffix_1_built);
        self.push(ASTType::UsesStmtSuffix(uses_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 312:
    ///
    /// `UsesStmtList /* Vec<T>::Push */: UsesStmtListGroup UsesStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_0(
        &mut self,
        _uses_stmt_list_group: &ParseTreeType<'t>,
        _uses_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut uses_stmt_list = pop_item!(self, uses_stmt_list, UsesStmtList, context);
        let uses_stmt_list_group =
            pop_item!(self, uses_stmt_list_group, UsesStmtListGroup, context);
        let uses_stmt_list_0_built = UsesStmtList {
            uses_stmt_list_group: Box::new(uses_stmt_list_group),
        };
        // Add an element to the vector
        uses_stmt_list.push(uses_stmt_list_0_built);
        self.push(ASTType::UsesStmtList(uses_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 313:
    ///
    /// `UsesStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let uses_stmt_list_group_0_built = UsesStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let uses_stmt_list_group_0_built =
            UsesStmtListGroup::WhenStmt(uses_stmt_list_group_0_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 314:
    ///
    /// `UsesStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let uses_stmt_list_group_1_built = UsesStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let uses_stmt_list_group_1_built =
            UsesStmtListGroup::IfFeatureStmt(uses_stmt_list_group_1_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 315:
    ///
    /// `UsesStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_2(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let uses_stmt_list_group_2_built = UsesStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let uses_stmt_list_group_2_built =
            UsesStmtListGroup::StatusStmt(uses_stmt_list_group_2_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 316:
    ///
    /// `UsesStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_3(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let uses_stmt_list_group_3_built = UsesStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let uses_stmt_list_group_3_built =
            UsesStmtListGroup::DescriptionStmt(uses_stmt_list_group_3_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 317:
    ///
    /// `UsesStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_4(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let uses_stmt_list_group_4_built = UsesStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let uses_stmt_list_group_4_built =
            UsesStmtListGroup::ReferenceStmt(uses_stmt_list_group_4_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 318:
    ///
    /// `UsesStmtListGroup: RefineStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_5(&mut self, _refine_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let refine_stmt = pop_item!(self, refine_stmt, RefineStmt, context);
        let uses_stmt_list_group_5_built = UsesStmtListGroupRefineStmt {
            refine_stmt: Box::new(refine_stmt),
        };
        let uses_stmt_list_group_5_built =
            UsesStmtListGroup::RefineStmt(uses_stmt_list_group_5_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 319:
    ///
    /// `UsesStmtListGroup: AugmentStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_group_6(&mut self, _augment_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let augment_stmt = pop_item!(self, augment_stmt, AugmentStmt, context);
        let uses_stmt_list_group_6_built = UsesStmtListGroupAugmentStmt {
            augment_stmt: Box::new(augment_stmt),
        };
        let uses_stmt_list_group_6_built =
            UsesStmtListGroup::AugmentStmt(uses_stmt_list_group_6_built);
        self.push(
            ASTType::UsesStmtListGroup(uses_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 320:
    ///
    /// `UsesStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn uses_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uses_stmt_list_1_built = Vec::new();
        self.push(ASTType::UsesStmtList(uses_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 321:
    ///
    /// `RefineStmt: KwRefine^ /* Clipped */ RefineArgStr RefineStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt(
        &mut self,
        _kw_refine: &ParseTreeType<'t>,
        _refine_arg_str: &ParseTreeType<'t>,
        _refine_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let refine_stmt_suffix = pop_item!(self, refine_stmt_suffix, RefineStmtSuffix, context);
        let refine_arg_str = pop_item!(self, refine_arg_str, RefineArgStr, context);
        self.pop(context);
        let refine_stmt_built = RefineStmt {
            refine_arg_str: Box::new(refine_arg_str),
            refine_stmt_suffix: Box::new(refine_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.refine_stmt(&refine_stmt_built)?;
        self.push(ASTType::RefineStmt(refine_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 322:
    ///
    /// `RefineStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let refine_stmt_suffix_0_built = RefineStmtSuffixSemicolon {};
        let refine_stmt_suffix_0_built = RefineStmtSuffix::Semicolon(refine_stmt_suffix_0_built);
        self.push(
            ASTType::RefineStmtSuffix(refine_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 323:
    ///
    /// `RefineStmtSuffix: LBrace^ /* Clipped */ RefineStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _refine_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let refine_stmt_list =
            pop_and_reverse_item!(self, refine_stmt_list, RefineStmtList, context);
        self.pop(context);
        let refine_stmt_suffix_1_built =
            RefineStmtSuffixLBraceRefineStmtListRBrace { refine_stmt_list };
        let refine_stmt_suffix_1_built =
            RefineStmtSuffix::LBraceRefineStmtListRBrace(refine_stmt_suffix_1_built);
        self.push(
            ASTType::RefineStmtSuffix(refine_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 324:
    ///
    /// `RefineStmtList /* Vec<T>::Push */: RefineStmtListGroup RefineStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_0(
        &mut self,
        _refine_stmt_list_group: &ParseTreeType<'t>,
        _refine_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut refine_stmt_list = pop_item!(self, refine_stmt_list, RefineStmtList, context);
        let refine_stmt_list_group =
            pop_item!(self, refine_stmt_list_group, RefineStmtListGroup, context);
        let refine_stmt_list_0_built = RefineStmtList {
            refine_stmt_list_group: Box::new(refine_stmt_list_group),
        };
        // Add an element to the vector
        refine_stmt_list.push(refine_stmt_list_0_built);
        self.push(ASTType::RefineStmtList(refine_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 325:
    ///
    /// `RefineStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let refine_stmt_list_group_0_built = RefineStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let refine_stmt_list_group_0_built =
            RefineStmtListGroup::IfFeatureStmt(refine_stmt_list_group_0_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 326:
    ///
    /// `RefineStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_1(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let refine_stmt_list_group_1_built = RefineStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let refine_stmt_list_group_1_built =
            RefineStmtListGroup::MustStmt(refine_stmt_list_group_1_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 327:
    ///
    /// `RefineStmtListGroup: PresenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_2(&mut self, _presence_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let presence_stmt = pop_item!(self, presence_stmt, PresenceStmt, context);
        let refine_stmt_list_group_2_built = RefineStmtListGroupPresenceStmt {
            presence_stmt: Box::new(presence_stmt),
        };
        let refine_stmt_list_group_2_built =
            RefineStmtListGroup::PresenceStmt(refine_stmt_list_group_2_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 328:
    ///
    /// `RefineStmtListGroup: DefaultStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_3(&mut self, _default_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt = pop_item!(self, default_stmt, DefaultStmt, context);
        let refine_stmt_list_group_3_built = RefineStmtListGroupDefaultStmt {
            default_stmt: Box::new(default_stmt),
        };
        let refine_stmt_list_group_3_built =
            RefineStmtListGroup::DefaultStmt(refine_stmt_list_group_3_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 329:
    ///
    /// `RefineStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_4(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let refine_stmt_list_group_4_built = RefineStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let refine_stmt_list_group_4_built =
            RefineStmtListGroup::ConfigStmt(refine_stmt_list_group_4_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 330:
    ///
    /// `RefineStmtListGroup: MandatoryStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_5(&mut self, _mandatory_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_stmt = pop_item!(self, mandatory_stmt, MandatoryStmt, context);
        let refine_stmt_list_group_5_built = RefineStmtListGroupMandatoryStmt {
            mandatory_stmt: Box::new(mandatory_stmt),
        };
        let refine_stmt_list_group_5_built =
            RefineStmtListGroup::MandatoryStmt(refine_stmt_list_group_5_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 331:
    ///
    /// `RefineStmtListGroup: MinElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_6(&mut self, _min_elements_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let min_elements_stmt = pop_item!(self, min_elements_stmt, MinElementsStmt, context);
        let refine_stmt_list_group_6_built = RefineStmtListGroupMinElementsStmt {
            min_elements_stmt: Box::new(min_elements_stmt),
        };
        let refine_stmt_list_group_6_built =
            RefineStmtListGroup::MinElementsStmt(refine_stmt_list_group_6_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 332:
    ///
    /// `RefineStmtListGroup: MaxElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_7(&mut self, _max_elements_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let max_elements_stmt = pop_item!(self, max_elements_stmt, MaxElementsStmt, context);
        let refine_stmt_list_group_7_built = RefineStmtListGroupMaxElementsStmt {
            max_elements_stmt: Box::new(max_elements_stmt),
        };
        let refine_stmt_list_group_7_built =
            RefineStmtListGroup::MaxElementsStmt(refine_stmt_list_group_7_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 333:
    ///
    /// `RefineStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_8(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let refine_stmt_list_group_8_built = RefineStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let refine_stmt_list_group_8_built =
            RefineStmtListGroup::DescriptionStmt(refine_stmt_list_group_8_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 334:
    ///
    /// `RefineStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_group_9(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let refine_stmt_list_group_9_built = RefineStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let refine_stmt_list_group_9_built =
            RefineStmtListGroup::ReferenceStmt(refine_stmt_list_group_9_built);
        self.push(
            ASTType::RefineStmtListGroup(refine_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 335:
    ///
    /// `RefineStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let refine_stmt_list_1_built = Vec::new();
        self.push(ASTType::RefineStmtList(refine_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 336:
    ///
    /// `RefineArgStr: RefineArg;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_arg_str_0(&mut self, _refine_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let refine_arg = pop_item!(self, refine_arg, RefineArg, context);
        let refine_arg_str_0_built = RefineArgStrRefineArg {
            refine_arg: Box::new(refine_arg),
        };
        let refine_arg_str_0_built = RefineArgStr::RefineArg(refine_arg_str_0_built);
        // Calling user action here
        self.user_grammar.refine_arg_str(&refine_arg_str_0_built)?;
        self.push(ASTType::RefineArgStr(refine_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 337:
    ///
    /// `RefineArgStr: <Keyword>'"' RefineArg <Keyword>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn refine_arg_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _refine_arg: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let refine_arg = pop_item!(self, refine_arg, RefineArg, context);
        let refine_arg_str_1_built = RefineArgStrDoubleQuotationRefineArgDoubleQuotation {
            double_quotation,
            refine_arg: Box::new(refine_arg),
            double_quotation0,
        };
        let refine_arg_str_1_built =
            RefineArgStr::DoubleQuotationRefineArgDoubleQuotation(refine_arg_str_1_built);
        // Calling user action here
        self.user_grammar.refine_arg_str(&refine_arg_str_1_built)?;
        self.push(ASTType::RefineArgStr(refine_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 338:
    ///
    /// `RefineArg: DescendantSchemaNodeid;`
    ///
    #[parol_runtime::function_name::named]
    fn refine_arg(&mut self, _descendant_schema_nodeid: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let descendant_schema_nodeid = pop_item!(
            self,
            descendant_schema_nodeid,
            DescendantSchemaNodeid,
            context
        );
        let refine_arg_built = RefineArg {
            descendant_schema_nodeid: Box::new(descendant_schema_nodeid),
        };
        // Calling user action here
        self.user_grammar.refine_arg(&refine_arg_built)?;
        self.push(ASTType::RefineArg(refine_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 339:
    ///
    /// `DescendantSchemaNodeid: IdentifierRef;`
    ///
    #[parol_runtime::function_name::named]
    fn descendant_schema_nodeid_0(&mut self, _identifier_ref: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let descendant_schema_nodeid_0_built = DescendantSchemaNodeidIdentifierRef {
            identifier_ref: Box::new(identifier_ref),
        };
        let descendant_schema_nodeid_0_built =
            DescendantSchemaNodeid::IdentifierRef(descendant_schema_nodeid_0_built);
        // Calling user action here
        self.user_grammar
            .descendant_schema_nodeid(&descendant_schema_nodeid_0_built)?;
        self.push(
            ASTType::DescendantSchemaNodeid(descendant_schema_nodeid_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 340:
    ///
    /// `DescendantSchemaNodeid: AbsoluteSchemaNodeid;`
    ///
    #[parol_runtime::function_name::named]
    fn descendant_schema_nodeid_1(
        &mut self,
        _absolute_schema_nodeid: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let absolute_schema_nodeid =
            pop_item!(self, absolute_schema_nodeid, AbsoluteSchemaNodeid, context);
        let descendant_schema_nodeid_1_built = DescendantSchemaNodeidAbsoluteSchemaNodeid {
            absolute_schema_nodeid: Box::new(absolute_schema_nodeid),
        };
        let descendant_schema_nodeid_1_built =
            DescendantSchemaNodeid::AbsoluteSchemaNodeid(descendant_schema_nodeid_1_built);
        // Calling user action here
        self.user_grammar
            .descendant_schema_nodeid(&descendant_schema_nodeid_1_built)?;
        self.push(
            ASTType::DescendantSchemaNodeid(descendant_schema_nodeid_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 341:
    ///
    /// `UnknownStmt: IdentifierRef Ystring UnknownStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt(
        &mut self,
        _identifier_ref: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _unknown_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt_suffix = pop_item!(self, unknown_stmt_suffix, UnknownStmtSuffix, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let unknown_stmt_built = UnknownStmt {
            identifier_ref: Box::new(identifier_ref),
            ystring: Box::new(ystring),
            unknown_stmt_suffix: Box::new(unknown_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.unknown_stmt(&unknown_stmt_built)?;
        self.push(ASTType::UnknownStmt(unknown_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 342:
    ///
    /// `UnknownStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let unknown_stmt_suffix_0_built = UnknownStmtSuffixSemicolon {};
        let unknown_stmt_suffix_0_built = UnknownStmtSuffix::Semicolon(unknown_stmt_suffix_0_built);
        self.push(
            ASTType::UnknownStmtSuffix(unknown_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 343:
    ///
    /// `UnknownStmtSuffix: LBrace^ /* Clipped */ UnknownStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _unknown_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt_list =
            pop_and_reverse_item!(self, unknown_stmt_list, UnknownStmtList, context);
        self.pop(context);
        let unknown_stmt_suffix_1_built =
            UnknownStmtSuffixLBraceUnknownStmtListRBrace { unknown_stmt_list };
        let unknown_stmt_suffix_1_built =
            UnknownStmtSuffix::LBraceUnknownStmtListRBrace(unknown_stmt_suffix_1_built);
        self.push(
            ASTType::UnknownStmtSuffix(unknown_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 344:
    ///
    /// `UnknownStmtList /* Vec<T>::Push */: UnknownStmtListGroup UnknownStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_list_0(
        &mut self,
        _unknown_stmt_list_group: &ParseTreeType<'t>,
        _unknown_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut unknown_stmt_list = pop_item!(self, unknown_stmt_list, UnknownStmtList, context);
        let unknown_stmt_list_group =
            pop_item!(self, unknown_stmt_list_group, UnknownStmtListGroup, context);
        let unknown_stmt_list_0_built = UnknownStmtList {
            unknown_stmt_list_group: Box::new(unknown_stmt_list_group),
        };
        // Add an element to the vector
        unknown_stmt_list.push(unknown_stmt_list_0_built);
        self.push(ASTType::UnknownStmtList(unknown_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 345:
    ///
    /// `UnknownStmtListGroup: TypeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_list_group_0(&mut self, _type_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt = pop_item!(self, type_stmt, TypeStmt, context);
        let unknown_stmt_list_group_0_built = UnknownStmtListGroupTypeStmt {
            type_stmt: Box::new(type_stmt),
        };
        let unknown_stmt_list_group_0_built =
            UnknownStmtListGroup::TypeStmt(unknown_stmt_list_group_0_built);
        self.push(
            ASTType::UnknownStmtListGroup(unknown_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 346:
    ///
    /// `UnknownStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let unknown_stmt_list_group_1_built = UnknownStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let unknown_stmt_list_group_1_built =
            UnknownStmtListGroup::DescriptionStmt(unknown_stmt_list_group_1_built);
        self.push(
            ASTType::UnknownStmtListGroup(unknown_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 347:
    ///
    /// `UnknownStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn unknown_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt_list_1_built = Vec::new();
        self.push(ASTType::UnknownStmtList(unknown_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 348:
    ///
    /// `LeafListStmt: KwLeafList^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ LeafListStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt(
        &mut self,
        _kw_leaf_list: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _leaf_list_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_list_stmt_list =
            pop_and_reverse_item!(self, leaf_list_stmt_list, LeafListStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let leaf_list_stmt_built = LeafListStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            leaf_list_stmt_list,
        };
        // Calling user action here
        self.user_grammar.leaf_list_stmt(&leaf_list_stmt_built)?;
        self.push(ASTType::LeafListStmt(leaf_list_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 349:
    ///
    /// `LeafListStmtList /* Vec<T>::Push */: LeafListStmtListGroup LeafListStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_0(
        &mut self,
        _leaf_list_stmt_list_group: &ParseTreeType<'t>,
        _leaf_list_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut leaf_list_stmt_list =
            pop_item!(self, leaf_list_stmt_list, LeafListStmtList, context);
        let leaf_list_stmt_list_group = pop_item!(
            self,
            leaf_list_stmt_list_group,
            LeafListStmtListGroup,
            context
        );
        let leaf_list_stmt_list_0_built = LeafListStmtList {
            leaf_list_stmt_list_group: Box::new(leaf_list_stmt_list_group),
        };
        // Add an element to the vector
        leaf_list_stmt_list.push(leaf_list_stmt_list_0_built);
        self.push(ASTType::LeafListStmtList(leaf_list_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 350:
    ///
    /// `LeafListStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let leaf_list_stmt_list_group_0_built = LeafListStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let leaf_list_stmt_list_group_0_built =
            LeafListStmtListGroup::WhenStmt(leaf_list_stmt_list_group_0_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 351:
    ///
    /// `LeafListStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let leaf_list_stmt_list_group_1_built = LeafListStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let leaf_list_stmt_list_group_1_built =
            LeafListStmtListGroup::IfFeatureStmt(leaf_list_stmt_list_group_1_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 352:
    ///
    /// `LeafListStmtListGroup: TypeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_2(&mut self, _type_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt = pop_item!(self, type_stmt, TypeStmt, context);
        let leaf_list_stmt_list_group_2_built = LeafListStmtListGroupTypeStmt {
            type_stmt: Box::new(type_stmt),
        };
        let leaf_list_stmt_list_group_2_built =
            LeafListStmtListGroup::TypeStmt(leaf_list_stmt_list_group_2_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 353:
    ///
    /// `LeafListStmtListGroup: UnitsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_3(&mut self, _units_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let units_stmt = pop_item!(self, units_stmt, UnitsStmt, context);
        let leaf_list_stmt_list_group_3_built = LeafListStmtListGroupUnitsStmt {
            units_stmt: Box::new(units_stmt),
        };
        let leaf_list_stmt_list_group_3_built =
            LeafListStmtListGroup::UnitsStmt(leaf_list_stmt_list_group_3_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 354:
    ///
    /// `LeafListStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_4(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let leaf_list_stmt_list_group_4_built = LeafListStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let leaf_list_stmt_list_group_4_built =
            LeafListStmtListGroup::MustStmt(leaf_list_stmt_list_group_4_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 355:
    ///
    /// `LeafListStmtListGroup: DefaultStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_5(&mut self, _default_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt = pop_item!(self, default_stmt, DefaultStmt, context);
        let leaf_list_stmt_list_group_5_built = LeafListStmtListGroupDefaultStmt {
            default_stmt: Box::new(default_stmt),
        };
        let leaf_list_stmt_list_group_5_built =
            LeafListStmtListGroup::DefaultStmt(leaf_list_stmt_list_group_5_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 356:
    ///
    /// `LeafListStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_6(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let leaf_list_stmt_list_group_6_built = LeafListStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let leaf_list_stmt_list_group_6_built =
            LeafListStmtListGroup::ConfigStmt(leaf_list_stmt_list_group_6_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 357:
    ///
    /// `LeafListStmtListGroup: MinElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_7(
        &mut self,
        _min_elements_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let min_elements_stmt = pop_item!(self, min_elements_stmt, MinElementsStmt, context);
        let leaf_list_stmt_list_group_7_built = LeafListStmtListGroupMinElementsStmt {
            min_elements_stmt: Box::new(min_elements_stmt),
        };
        let leaf_list_stmt_list_group_7_built =
            LeafListStmtListGroup::MinElementsStmt(leaf_list_stmt_list_group_7_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 358:
    ///
    /// `LeafListStmtListGroup: MaxElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_8(
        &mut self,
        _max_elements_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let max_elements_stmt = pop_item!(self, max_elements_stmt, MaxElementsStmt, context);
        let leaf_list_stmt_list_group_8_built = LeafListStmtListGroupMaxElementsStmt {
            max_elements_stmt: Box::new(max_elements_stmt),
        };
        let leaf_list_stmt_list_group_8_built =
            LeafListStmtListGroup::MaxElementsStmt(leaf_list_stmt_list_group_8_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 359:
    ///
    /// `LeafListStmtListGroup: OrderedByStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_9(&mut self, _ordered_by_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ordered_by_stmt = pop_item!(self, ordered_by_stmt, OrderedByStmt, context);
        let leaf_list_stmt_list_group_9_built = LeafListStmtListGroupOrderedByStmt {
            ordered_by_stmt: Box::new(ordered_by_stmt),
        };
        let leaf_list_stmt_list_group_9_built =
            LeafListStmtListGroup::OrderedByStmt(leaf_list_stmt_list_group_9_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 360:
    ///
    /// `LeafListStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_10(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let leaf_list_stmt_list_group_10_built = LeafListStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let leaf_list_stmt_list_group_10_built =
            LeafListStmtListGroup::StatusStmt(leaf_list_stmt_list_group_10_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_10_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 361:
    ///
    /// `LeafListStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_11(
        &mut self,
        _description_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let leaf_list_stmt_list_group_11_built = LeafListStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let leaf_list_stmt_list_group_11_built =
            LeafListStmtListGroup::DescriptionStmt(leaf_list_stmt_list_group_11_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_11_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 362:
    ///
    /// `LeafListStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_12(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let leaf_list_stmt_list_group_12_built = LeafListStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let leaf_list_stmt_list_group_12_built =
            LeafListStmtListGroup::ReferenceStmt(leaf_list_stmt_list_group_12_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_12_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 363:
    ///
    /// `LeafListStmtListGroup: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_group_13(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let leaf_list_stmt_list_group_13_built = LeafListStmtListGroupUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let leaf_list_stmt_list_group_13_built =
            LeafListStmtListGroup::UnknownStmt(leaf_list_stmt_list_group_13_built);
        self.push(
            ASTType::LeafListStmtListGroup(leaf_list_stmt_list_group_13_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 364:
    ///
    /// `LeafListStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_list_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_list_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::LeafListStmtList(leaf_list_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 365:
    ///
    /// `LeafStmt: KwLeaf^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ LeafStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt(
        &mut self,
        _kw_leaf: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _leaf_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_stmt_list = pop_and_reverse_item!(self, leaf_stmt_list, LeafStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let leaf_stmt_built = LeafStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            leaf_stmt_list,
        };
        // Calling user action here
        self.user_grammar.leaf_stmt(&leaf_stmt_built)?;
        self.push(ASTType::LeafStmt(leaf_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 366:
    ///
    /// `LeafStmtList /* Vec<T>::Push */: LeafStmtListGroup LeafStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_0(
        &mut self,
        _leaf_stmt_list_group: &ParseTreeType<'t>,
        _leaf_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut leaf_stmt_list = pop_item!(self, leaf_stmt_list, LeafStmtList, context);
        let leaf_stmt_list_group =
            pop_item!(self, leaf_stmt_list_group, LeafStmtListGroup, context);
        let leaf_stmt_list_0_built = LeafStmtList {
            leaf_stmt_list_group: Box::new(leaf_stmt_list_group),
        };
        // Add an element to the vector
        leaf_stmt_list.push(leaf_stmt_list_0_built);
        self.push(ASTType::LeafStmtList(leaf_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 367:
    ///
    /// `LeafStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let leaf_stmt_list_group_0_built = LeafStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let leaf_stmt_list_group_0_built =
            LeafStmtListGroup::WhenStmt(leaf_stmt_list_group_0_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 368:
    ///
    /// `LeafStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_1(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let leaf_stmt_list_group_1_built = LeafStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let leaf_stmt_list_group_1_built =
            LeafStmtListGroup::StatusStmt(leaf_stmt_list_group_1_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 369:
    ///
    /// `LeafStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_2(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let leaf_stmt_list_group_2_built = LeafStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let leaf_stmt_list_group_2_built =
            LeafStmtListGroup::IfFeatureStmt(leaf_stmt_list_group_2_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 370:
    ///
    /// `LeafStmtListGroup: TypeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_3(&mut self, _type_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt = pop_item!(self, type_stmt, TypeStmt, context);
        let leaf_stmt_list_group_3_built = LeafStmtListGroupTypeStmt {
            type_stmt: Box::new(type_stmt),
        };
        let leaf_stmt_list_group_3_built =
            LeafStmtListGroup::TypeStmt(leaf_stmt_list_group_3_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 371:
    ///
    /// `LeafStmtListGroup: UnitsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_4(&mut self, _units_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let units_stmt = pop_item!(self, units_stmt, UnitsStmt, context);
        let leaf_stmt_list_group_4_built = LeafStmtListGroupUnitsStmt {
            units_stmt: Box::new(units_stmt),
        };
        let leaf_stmt_list_group_4_built =
            LeafStmtListGroup::UnitsStmt(leaf_stmt_list_group_4_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 372:
    ///
    /// `LeafStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_5(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let leaf_stmt_list_group_5_built = LeafStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let leaf_stmt_list_group_5_built =
            LeafStmtListGroup::MustStmt(leaf_stmt_list_group_5_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 373:
    ///
    /// `LeafStmtListGroup: DefaultStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_6(&mut self, _default_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt = pop_item!(self, default_stmt, DefaultStmt, context);
        let leaf_stmt_list_group_6_built = LeafStmtListGroupDefaultStmt {
            default_stmt: Box::new(default_stmt),
        };
        let leaf_stmt_list_group_6_built =
            LeafStmtListGroup::DefaultStmt(leaf_stmt_list_group_6_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 374:
    ///
    /// `LeafStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_7(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let leaf_stmt_list_group_7_built = LeafStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let leaf_stmt_list_group_7_built =
            LeafStmtListGroup::ConfigStmt(leaf_stmt_list_group_7_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 375:
    ///
    /// `LeafStmtListGroup: MandatoryStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_8(&mut self, _mandatory_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_stmt = pop_item!(self, mandatory_stmt, MandatoryStmt, context);
        let leaf_stmt_list_group_8_built = LeafStmtListGroupMandatoryStmt {
            mandatory_stmt: Box::new(mandatory_stmt),
        };
        let leaf_stmt_list_group_8_built =
            LeafStmtListGroup::MandatoryStmt(leaf_stmt_list_group_8_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 376:
    ///
    /// `LeafStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_9(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let leaf_stmt_list_group_9_built = LeafStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let leaf_stmt_list_group_9_built =
            LeafStmtListGroup::DescriptionStmt(leaf_stmt_list_group_9_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 377:
    ///
    /// `LeafStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_10(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let leaf_stmt_list_group_10_built = LeafStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let leaf_stmt_list_group_10_built =
            LeafStmtListGroup::ReferenceStmt(leaf_stmt_list_group_10_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_10_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 378:
    ///
    /// `LeafStmtListGroup: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_group_11(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let leaf_stmt_list_group_11_built = LeafStmtListGroupUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let leaf_stmt_list_group_11_built =
            LeafStmtListGroup::UnknownStmt(leaf_stmt_list_group_11_built);
        self.push(
            ASTType::LeafStmtListGroup(leaf_stmt_list_group_11_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 379:
    ///
    /// `LeafStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn leaf_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leaf_stmt_list_1_built = Vec::new();
        self.push(ASTType::LeafStmtList(leaf_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 380:
    ///
    /// `MustStmt: 'must'^ /* Clipped */ Ystring MustStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt(
        &mut self,
        _must: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _must_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt_suffix = pop_item!(self, must_stmt_suffix, MustStmtSuffix, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let must_stmt_built = MustStmt {
            ystring: Box::new(ystring),
            must_stmt_suffix: Box::new(must_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.must_stmt(&must_stmt_built)?;
        self.push(ASTType::MustStmt(must_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 381:
    ///
    /// `MustStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let must_stmt_suffix_0_built = MustStmtSuffixSemicolon {};
        let must_stmt_suffix_0_built = MustStmtSuffix::Semicolon(must_stmt_suffix_0_built);
        self.push(ASTType::MustStmtSuffix(must_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 382:
    ///
    /// `MustStmtSuffix: LBrace^ /* Clipped */ MustStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _must_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt_list = pop_and_reverse_item!(self, must_stmt_list, MustStmtList, context);
        self.pop(context);
        let must_stmt_suffix_1_built = MustStmtSuffixLBraceMustStmtListRBrace { must_stmt_list };
        let must_stmt_suffix_1_built =
            MustStmtSuffix::LBraceMustStmtListRBrace(must_stmt_suffix_1_built);
        self.push(ASTType::MustStmtSuffix(must_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 383:
    ///
    /// `MustStmtList /* Vec<T>::Push */: MustStmtListGroup MustStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_list_0(
        &mut self,
        _must_stmt_list_group: &ParseTreeType<'t>,
        _must_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut must_stmt_list = pop_item!(self, must_stmt_list, MustStmtList, context);
        let must_stmt_list_group =
            pop_item!(self, must_stmt_list_group, MustStmtListGroup, context);
        let must_stmt_list_0_built = MustStmtList {
            must_stmt_list_group: Box::new(must_stmt_list_group),
        };
        // Add an element to the vector
        must_stmt_list.push(must_stmt_list_0_built);
        self.push(ASTType::MustStmtList(must_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 384:
    ///
    /// `MustStmtListGroup: ErrorMessage;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_list_group_0(&mut self, _error_message: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let error_message = pop_item!(self, error_message, ErrorMessage, context);
        let must_stmt_list_group_0_built = MustStmtListGroupErrorMessage {
            error_message: Box::new(error_message),
        };
        let must_stmt_list_group_0_built =
            MustStmtListGroup::ErrorMessage(must_stmt_list_group_0_built);
        self.push(
            ASTType::MustStmtListGroup(must_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 385:
    ///
    /// `MustStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let must_stmt_list_group_1_built = MustStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let must_stmt_list_group_1_built =
            MustStmtListGroup::DescriptionStmt(must_stmt_list_group_1_built);
        self.push(
            ASTType::MustStmtListGroup(must_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 386:
    ///
    /// `MustStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn must_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt_list_1_built = Vec::new();
        self.push(ASTType::MustStmtList(must_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 387:
    ///
    /// `ErrorMessage: 'error-message' Ystring Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn error_message(
        &mut self,
        error_minus_message: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let error_minus_message = error_minus_message.token()?.clone();
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let error_message_built = ErrorMessage {
            error_minus_message,
            ystring: Box::new(ystring),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.error_message(&error_message_built)?;
        self.push(ASTType::ErrorMessage(error_message_built), context);
        Ok(())
    }

    /// Semantic action for production 388:
    ///
    /// `UnitsStmt: 'units' Ystring Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn units_stmt(
        &mut self,
        units: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let units = units.token()?.clone();
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let units_stmt_built = UnitsStmt {
            units,
            ystring: Box::new(ystring),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.units_stmt(&units_stmt_built)?;
        self.push(ASTType::UnitsStmt(units_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 389:
    ///
    /// `ConfigStmt: KwConfig^ /* Clipped */ MandatoryArgStr Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn config_stmt(
        &mut self,
        _kw_config: &ParseTreeType<'t>,
        _mandatory_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let mandatory_arg_str = pop_item!(self, mandatory_arg_str, MandatoryArgStr, context);
        self.pop(context);
        let config_stmt_built = ConfigStmt {
            mandatory_arg_str: Box::new(mandatory_arg_str),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.config_stmt(&config_stmt_built)?;
        self.push(ASTType::ConfigStmt(config_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 390:
    ///
    /// `MandatoryStmt: KwMandatory^ /* Clipped */ MandatoryArgStr Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn mandatory_stmt(
        &mut self,
        _kw_mandatory: &ParseTreeType<'t>,
        _mandatory_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let mandatory_arg_str = pop_item!(self, mandatory_arg_str, MandatoryArgStr, context);
        self.pop(context);
        let mandatory_stmt_built = MandatoryStmt {
            mandatory_arg_str: Box::new(mandatory_arg_str),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.mandatory_stmt(&mandatory_stmt_built)?;
        self.push(ASTType::MandatoryStmt(mandatory_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 391:
    ///
    /// `MandatoryArgStr: MandatoryArg;`
    ///
    #[parol_runtime::function_name::named]
    fn mandatory_arg_str_0(&mut self, _mandatory_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_arg = pop_item!(self, mandatory_arg, MandatoryArg, context);
        let mandatory_arg_str_0_built = MandatoryArgStrMandatoryArg {
            mandatory_arg: Box::new(mandatory_arg),
        };
        let mandatory_arg_str_0_built = MandatoryArgStr::MandatoryArg(mandatory_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .mandatory_arg_str(&mandatory_arg_str_0_built)?;
        self.push(ASTType::MandatoryArgStr(mandatory_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 392:
    ///
    /// `MandatoryArgStr: <Mandatory>'"' MandatoryArg <Mandatory>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn mandatory_arg_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _mandatory_arg: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let mandatory_arg = pop_item!(self, mandatory_arg, MandatoryArg, context);
        let mandatory_arg_str_1_built = MandatoryArgStrDoubleQuotationMandatoryArgDoubleQuotation {
            double_quotation,
            mandatory_arg: Box::new(mandatory_arg),
            double_quotation0,
        };
        let mandatory_arg_str_1_built =
            MandatoryArgStr::DoubleQuotationMandatoryArgDoubleQuotation(mandatory_arg_str_1_built);
        // Calling user action here
        self.user_grammar
            .mandatory_arg_str(&mandatory_arg_str_1_built)?;
        self.push(ASTType::MandatoryArgStr(mandatory_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 393:
    ///
    /// `MandatoryArg: <Mandatory>/true|false/;`
    ///
    #[parol_runtime::function_name::named]
    fn mandatory_arg(&mut self, mandatory_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_arg = mandatory_arg.token()?.clone();
        let mandatory_arg_built = MandatoryArg { mandatory_arg };
        // Calling user action here
        self.user_grammar.mandatory_arg(&mandatory_arg_built)?;
        self.push(ASTType::MandatoryArg(mandatory_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 394:
    ///
    /// `ListStmt: KwList^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ ListStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt(
        &mut self,
        _kw_list: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _list_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let list_stmt_list = pop_and_reverse_item!(self, list_stmt_list, ListStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let list_stmt_built = ListStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            list_stmt_list,
        };
        // Calling user action here
        self.user_grammar.list_stmt(&list_stmt_built)?;
        self.push(ASTType::ListStmt(list_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 395:
    ///
    /// `ListStmtList /* Vec<T>::Push */: ListStmtListGroup ListStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_0(
        &mut self,
        _list_stmt_list_group: &ParseTreeType<'t>,
        _list_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut list_stmt_list = pop_item!(self, list_stmt_list, ListStmtList, context);
        let list_stmt_list_group =
            pop_item!(self, list_stmt_list_group, ListStmtListGroup, context);
        let list_stmt_list_0_built = ListStmtList {
            list_stmt_list_group: Box::new(list_stmt_list_group),
        };
        // Add an element to the vector
        list_stmt_list.push(list_stmt_list_0_built);
        self.push(ASTType::ListStmtList(list_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 396:
    ///
    /// `ListStmtListGroup: WhenStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_0(&mut self, _when_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let when_stmt = pop_item!(self, when_stmt, WhenStmt, context);
        let list_stmt_list_group_0_built = ListStmtListGroupWhenStmt {
            when_stmt: Box::new(when_stmt),
        };
        let list_stmt_list_group_0_built =
            ListStmtListGroup::WhenStmt(list_stmt_list_group_0_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 397:
    ///
    /// `ListStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_1(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let list_stmt_list_group_1_built = ListStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let list_stmt_list_group_1_built =
            ListStmtListGroup::IfFeatureStmt(list_stmt_list_group_1_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 398:
    ///
    /// `ListStmtListGroup: MustStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_2(&mut self, _must_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let must_stmt = pop_item!(self, must_stmt, MustStmt, context);
        let list_stmt_list_group_2_built = ListStmtListGroupMustStmt {
            must_stmt: Box::new(must_stmt),
        };
        let list_stmt_list_group_2_built =
            ListStmtListGroup::MustStmt(list_stmt_list_group_2_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 399:
    ///
    /// `ListStmtListGroup: KeyStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_3(&mut self, _key_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_stmt = pop_item!(self, key_stmt, KeyStmt, context);
        let list_stmt_list_group_3_built = ListStmtListGroupKeyStmt {
            key_stmt: Box::new(key_stmt),
        };
        let list_stmt_list_group_3_built = ListStmtListGroup::KeyStmt(list_stmt_list_group_3_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 400:
    ///
    /// `ListStmtListGroup: ConfigStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_4(&mut self, _config_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let config_stmt = pop_item!(self, config_stmt, ConfigStmt, context);
        let list_stmt_list_group_4_built = ListStmtListGroupConfigStmt {
            config_stmt: Box::new(config_stmt),
        };
        let list_stmt_list_group_4_built =
            ListStmtListGroup::ConfigStmt(list_stmt_list_group_4_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 401:
    ///
    /// `ListStmtListGroup: MinElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_5(&mut self, _min_elements_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let min_elements_stmt = pop_item!(self, min_elements_stmt, MinElementsStmt, context);
        let list_stmt_list_group_5_built = ListStmtListGroupMinElementsStmt {
            min_elements_stmt: Box::new(min_elements_stmt),
        };
        let list_stmt_list_group_5_built =
            ListStmtListGroup::MinElementsStmt(list_stmt_list_group_5_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 402:
    ///
    /// `ListStmtListGroup: MaxElementsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_6(&mut self, _max_elements_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let max_elements_stmt = pop_item!(self, max_elements_stmt, MaxElementsStmt, context);
        let list_stmt_list_group_6_built = ListStmtListGroupMaxElementsStmt {
            max_elements_stmt: Box::new(max_elements_stmt),
        };
        let list_stmt_list_group_6_built =
            ListStmtListGroup::MaxElementsStmt(list_stmt_list_group_6_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 403:
    ///
    /// `ListStmtListGroup: OrderedByStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_7(&mut self, _ordered_by_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ordered_by_stmt = pop_item!(self, ordered_by_stmt, OrderedByStmt, context);
        let list_stmt_list_group_7_built = ListStmtListGroupOrderedByStmt {
            ordered_by_stmt: Box::new(ordered_by_stmt),
        };
        let list_stmt_list_group_7_built =
            ListStmtListGroup::OrderedByStmt(list_stmt_list_group_7_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 404:
    ///
    /// `ListStmtListGroup: StatusStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_8(&mut self, _status_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let status_stmt = pop_item!(self, status_stmt, StatusStmt, context);
        let list_stmt_list_group_8_built = ListStmtListGroupStatusStmt {
            status_stmt: Box::new(status_stmt),
        };
        let list_stmt_list_group_8_built =
            ListStmtListGroup::StatusStmt(list_stmt_list_group_8_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_8_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 405:
    ///
    /// `ListStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_9(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let list_stmt_list_group_9_built = ListStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let list_stmt_list_group_9_built =
            ListStmtListGroup::DescriptionStmt(list_stmt_list_group_9_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_9_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 406:
    ///
    /// `ListStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_10(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let list_stmt_list_group_10_built = ListStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let list_stmt_list_group_10_built =
            ListStmtListGroup::ReferenceStmt(list_stmt_list_group_10_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_10_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 407:
    ///
    /// `ListStmtListGroup: DataDefStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_11(&mut self, _data_def_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let data_def_stmt = pop_item!(self, data_def_stmt, DataDefStmt, context);
        let list_stmt_list_group_11_built = ListStmtListGroupDataDefStmt {
            data_def_stmt: Box::new(data_def_stmt),
        };
        let list_stmt_list_group_11_built =
            ListStmtListGroup::DataDefStmt(list_stmt_list_group_11_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_11_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 408:
    ///
    /// `ListStmtListGroup: ActionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_12(&mut self, _action_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let action_stmt = pop_item!(self, action_stmt, ActionStmt, context);
        let list_stmt_list_group_12_built = ListStmtListGroupActionStmt {
            action_stmt: Box::new(action_stmt),
        };
        let list_stmt_list_group_12_built =
            ListStmtListGroup::ActionStmt(list_stmt_list_group_12_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_12_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 409:
    ///
    /// `ListStmtListGroup: NotificationStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_13(&mut self, _notification_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let notification_stmt = pop_item!(self, notification_stmt, NotificationStmt, context);
        let list_stmt_list_group_13_built = ListStmtListGroupNotificationStmt {
            notification_stmt: Box::new(notification_stmt),
        };
        let list_stmt_list_group_13_built =
            ListStmtListGroup::NotificationStmt(list_stmt_list_group_13_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_13_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 410:
    ///
    /// `ListStmtListGroup: UnknownStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_group_14(&mut self, _unknown_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let unknown_stmt = pop_item!(self, unknown_stmt, UnknownStmt, context);
        let list_stmt_list_group_14_built = ListStmtListGroupUnknownStmt {
            unknown_stmt: Box::new(unknown_stmt),
        };
        let list_stmt_list_group_14_built =
            ListStmtListGroup::UnknownStmt(list_stmt_list_group_14_built);
        self.push(
            ASTType::ListStmtListGroup(list_stmt_list_group_14_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 411:
    ///
    /// `ListStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn list_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let list_stmt_list_1_built = Vec::new();
        self.push(ASTType::ListStmtList(list_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 412:
    ///
    /// `OrderedByStmt: KwOrderedBy^ /* Clipped */ OrderedByArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn ordered_by_stmt(
        &mut self,
        _kw_ordered_by: &ParseTreeType<'t>,
        _ordered_by_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ordered_by_arg_str = pop_item!(self, ordered_by_arg_str, OrderedByArgStr, context);
        self.pop(context);
        let ordered_by_stmt_built = OrderedByStmt {
            ordered_by_arg_str: Box::new(ordered_by_arg_str),
        };
        // Calling user action here
        self.user_grammar.ordered_by_stmt(&ordered_by_stmt_built)?;
        self.push(ASTType::OrderedByStmt(ordered_by_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 413:
    ///
    /// `OrderedByArgStr: OrderedByArg;`
    ///
    #[parol_runtime::function_name::named]
    fn ordered_by_arg_str_0(&mut self, _ordered_by_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ordered_by_arg = pop_item!(self, ordered_by_arg, OrderedByArg, context);
        let ordered_by_arg_str_0_built = OrderedByArgStrOrderedByArg {
            ordered_by_arg: Box::new(ordered_by_arg),
        };
        let ordered_by_arg_str_0_built = OrderedByArgStr::OrderedByArg(ordered_by_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .ordered_by_arg_str(&ordered_by_arg_str_0_built)?;
        self.push(
            ASTType::OrderedByArgStr(ordered_by_arg_str_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 414:
    ///
    /// `OrderedByArgStr: <Ordered>'"' OrderedByArg <Ordered>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn ordered_by_arg_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _ordered_by_arg: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let ordered_by_arg = pop_item!(self, ordered_by_arg, OrderedByArg, context);
        let ordered_by_arg_str_1_built =
            OrderedByArgStrDoubleQuotationOrderedByArgDoubleQuotation {
                double_quotation,
                ordered_by_arg: Box::new(ordered_by_arg),
                double_quotation0,
            };
        let ordered_by_arg_str_1_built =
            OrderedByArgStr::DoubleQuotationOrderedByArgDoubleQuotation(ordered_by_arg_str_1_built);
        // Calling user action here
        self.user_grammar
            .ordered_by_arg_str(&ordered_by_arg_str_1_built)?;
        self.push(
            ASTType::OrderedByArgStr(ordered_by_arg_str_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 415:
    ///
    /// `OrderedByArg: <Ordered>/user|system/;`
    ///
    #[parol_runtime::function_name::named]
    fn ordered_by_arg(&mut self, ordered_by_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ordered_by_arg = ordered_by_arg.token()?.clone();
        let ordered_by_arg_built = OrderedByArg { ordered_by_arg };
        // Calling user action here
        self.user_grammar.ordered_by_arg(&ordered_by_arg_built)?;
        self.push(ASTType::OrderedByArg(ordered_by_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 416:
    ///
    /// `DefaultStmt: KwDefault^ /* Clipped */ DefaultStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn default_stmt(
        &mut self,
        _kw_default: &ParseTreeType<'t>,
        _default_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let default_stmt_suffix = pop_item!(self, default_stmt_suffix, DefaultStmtSuffix, context);
        self.pop(context);
        let default_stmt_built = DefaultStmt {
            default_stmt_suffix: Box::new(default_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.default_stmt(&default_stmt_built)?;
        self.push(ASTType::DefaultStmt(default_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 417:
    ///
    /// `DefaultStmtSuffix: AsciiNoSemicolon Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn default_stmt_suffix_0(
        &mut self,
        _ascii_no_semicolon: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ascii_no_semicolon = pop_item!(self, ascii_no_semicolon, AsciiNoSemicolon, context);
        let default_stmt_suffix_0_built = DefaultStmtSuffixAsciiNoSemicolonSemicolon {
            ascii_no_semicolon: Box::new(ascii_no_semicolon),
        };
        let default_stmt_suffix_0_built =
            DefaultStmtSuffix::AsciiNoSemicolonSemicolon(default_stmt_suffix_0_built);
        self.push(
            ASTType::DefaultStmtSuffix(default_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 418:
    ///
    /// `DefaultStmtSuffix: <Default>'"' AsciiNoSemicolon <Default>'"' Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn default_stmt_suffix_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _ascii_no_semicolon: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        self.pop(context);
        let ascii_no_semicolon = pop_item!(self, ascii_no_semicolon, AsciiNoSemicolon, context);
        let default_stmt_suffix_1_built =
            DefaultStmtSuffixDoubleQuotationAsciiNoSemicolonDoubleQuotationSemicolon {
                double_quotation,
                ascii_no_semicolon: Box::new(ascii_no_semicolon),
                double_quotation0,
            };
        let default_stmt_suffix_1_built =
            DefaultStmtSuffix::DoubleQuotationAsciiNoSemicolonDoubleQuotationSemicolon(
                default_stmt_suffix_1_built,
            );
        self.push(
            ASTType::DefaultStmtSuffix(default_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 419:
    ///
    /// `MaxElementsStmt: 'max-elements'^ /* Clipped */ /[1-9][0-9]*/ Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn max_elements_stmt(
        &mut self,
        _max_minus_elements: &ParseTreeType<'t>,
        l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star =
            l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star
                .token()?
                .clone();
        self.pop(context);
        let max_elements_stmt_built = MaxElementsStmt {
            l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star,
        };
        // Calling user action here
        self.user_grammar
            .max_elements_stmt(&max_elements_stmt_built)?;
        self.push(ASTType::MaxElementsStmt(max_elements_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 420:
    ///
    /// `MinElementsStmt: 'min-elements'^ /* Clipped */ /[1-9][0-9]*/ Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn min_elements_stmt(
        &mut self,
        _min_minus_elements: &ParseTreeType<'t>,
        l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star =
            l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star
                .token()?
                .clone();
        self.pop(context);
        let min_elements_stmt_built = MinElementsStmt {
            l_bracket1_minus9_r_bracket_l_bracket0_minus9_r_bracket_star,
        };
        // Calling user action here
        self.user_grammar
            .min_elements_stmt(&min_elements_stmt_built)?;
        self.push(ASTType::MinElementsStmt(min_elements_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 421:
    ///
    /// `TypeStmt: KwType^ /* Clipped */ IdentifierRefArgStr TypeStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt(
        &mut self,
        _kw_type: &ParseTreeType<'t>,
        _identifier_ref_arg_str: &ParseTreeType<'t>,
        _type_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt_suffix = pop_item!(self, type_stmt_suffix, TypeStmtSuffix, context);
        let identifier_ref_arg_str =
            pop_item!(self, identifier_ref_arg_str, IdentifierRefArgStr, context);
        self.pop(context);
        let type_stmt_built = TypeStmt {
            identifier_ref_arg_str: Box::new(identifier_ref_arg_str),
            type_stmt_suffix: Box::new(type_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.type_stmt(&type_stmt_built)?;
        self.push(ASTType::TypeStmt(type_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 422:
    ///
    /// `TypeStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let type_stmt_suffix_0_built = TypeStmtSuffixSemicolon {};
        let type_stmt_suffix_0_built = TypeStmtSuffix::Semicolon(type_stmt_suffix_0_built);
        self.push(ASTType::TypeStmtSuffix(type_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 423:
    ///
    /// `TypeStmtSuffix: LBrace^ /* Clipped */ TypeStmtList /* Vec */ <INITIAL, Keyword>'}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _type_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt_list = pop_and_reverse_item!(self, type_stmt_list, TypeStmtList, context);
        self.pop(context);
        let type_stmt_suffix_1_built = TypeStmtSuffixLBraceTypeStmtListRBrace { type_stmt_list };
        let type_stmt_suffix_1_built =
            TypeStmtSuffix::LBraceTypeStmtListRBrace(type_stmt_suffix_1_built);
        self.push(ASTType::TypeStmtSuffix(type_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 424:
    ///
    /// `TypeStmtList /* Vec<T>::Push */: TypeStmtListGroup TypeStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_0(
        &mut self,
        _type_stmt_list_group: &ParseTreeType<'t>,
        _type_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut type_stmt_list = pop_item!(self, type_stmt_list, TypeStmtList, context);
        let type_stmt_list_group =
            pop_item!(self, type_stmt_list_group, TypeStmtListGroup, context);
        let type_stmt_list_0_built = TypeStmtList {
            type_stmt_list_group: Box::new(type_stmt_list_group),
        };
        // Add an element to the vector
        type_stmt_list.push(type_stmt_list_0_built);
        self.push(ASTType::TypeStmtList(type_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 425:
    ///
    /// `TypeStmtListGroup: FractionDigitsStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_0(&mut self, _fraction_digits_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let fraction_digits_stmt =
            pop_item!(self, fraction_digits_stmt, FractionDigitsStmt, context);
        let type_stmt_list_group_0_built = TypeStmtListGroupFractionDigitsStmt {
            fraction_digits_stmt: Box::new(fraction_digits_stmt),
        };
        let type_stmt_list_group_0_built =
            TypeStmtListGroup::FractionDigitsStmt(type_stmt_list_group_0_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 426:
    ///
    /// `TypeStmtListGroup: EnumStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_1(&mut self, _enum_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let enum_stmt = pop_item!(self, enum_stmt, EnumStmt, context);
        let type_stmt_list_group_1_built = TypeStmtListGroupEnumStmt {
            enum_stmt: Box::new(enum_stmt),
        };
        let type_stmt_list_group_1_built =
            TypeStmtListGroup::EnumStmt(type_stmt_list_group_1_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 427:
    ///
    /// `TypeStmtListGroup: BaseStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_2(&mut self, _base_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let base_stmt = pop_item!(self, base_stmt, BaseStmt, context);
        let type_stmt_list_group_2_built = TypeStmtListGroupBaseStmt {
            base_stmt: Box::new(base_stmt),
        };
        let type_stmt_list_group_2_built =
            TypeStmtListGroup::BaseStmt(type_stmt_list_group_2_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 428:
    ///
    /// `TypeStmtListGroup: LeafrefSpecification;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_3(&mut self, _leafref_specification: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let leafref_specification =
            pop_item!(self, leafref_specification, LeafrefSpecification, context);
        let type_stmt_list_group_3_built = TypeStmtListGroupLeafrefSpecification {
            leafref_specification: Box::new(leafref_specification),
        };
        let type_stmt_list_group_3_built =
            TypeStmtListGroup::LeafrefSpecification(type_stmt_list_group_3_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 429:
    ///
    /// `TypeStmtListGroup: StringRestrictions;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_4(&mut self, _string_restrictions: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let string_restrictions = pop_item!(self, string_restrictions, StringRestrictions, context);
        let type_stmt_list_group_4_built = TypeStmtListGroupStringRestrictions {
            string_restrictions: Box::new(string_restrictions),
        };
        let type_stmt_list_group_4_built =
            TypeStmtListGroup::StringRestrictions(type_stmt_list_group_4_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 430:
    ///
    /// `TypeStmtListGroup: RangeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_5(&mut self, _range_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let range_stmt = pop_item!(self, range_stmt, RangeStmt, context);
        let type_stmt_list_group_5_built = TypeStmtListGroupRangeStmt {
            range_stmt: Box::new(range_stmt),
        };
        let type_stmt_list_group_5_built =
            TypeStmtListGroup::RangeStmt(type_stmt_list_group_5_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 431:
    ///
    /// `TypeStmtListGroup: BitStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_6(&mut self, _bit_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let bit_stmt = pop_item!(self, bit_stmt, BitStmt, context);
        let type_stmt_list_group_6_built = TypeStmtListGroupBitStmt {
            bit_stmt: Box::new(bit_stmt),
        };
        let type_stmt_list_group_6_built = TypeStmtListGroup::BitStmt(type_stmt_list_group_6_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 432:
    ///
    /// `TypeStmtListGroup: TypeStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_group_7(&mut self, _type_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt = pop_item!(self, type_stmt, TypeStmt, context);
        let type_stmt_list_group_7_built = TypeStmtListGroupTypeStmt {
            type_stmt: Box::new(type_stmt),
        };
        let type_stmt_list_group_7_built =
            TypeStmtListGroup::TypeStmt(type_stmt_list_group_7_built);
        self.push(
            ASTType::TypeStmtListGroup(type_stmt_list_group_7_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 433:
    ///
    /// `TypeStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn type_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let type_stmt_list_1_built = Vec::new();
        self.push(ASTType::TypeStmtList(type_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 434:
    ///
    /// `FractionDigitsStmt: KwFractionDigits^ /* Clipped */ FractionDigitsArg Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn fraction_digits_stmt(
        &mut self,
        _kw_fraction_digits: &ParseTreeType<'t>,
        _fraction_digits_arg: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let fraction_digits_arg = pop_item!(self, fraction_digits_arg, FractionDigitsArg, context);
        self.pop(context);
        let fraction_digits_stmt_built = FractionDigitsStmt {
            fraction_digits_arg: Box::new(fraction_digits_arg),
        };
        // Calling user action here
        self.user_grammar
            .fraction_digits_stmt(&fraction_digits_stmt_built)?;
        self.push(
            ASTType::FractionDigitsStmt(fraction_digits_stmt_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 435:
    ///
    /// `FractionDigitsArg: <Fraction>/1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|/;`
    ///
    #[parol_runtime::function_name::named]
    fn fraction_digits_arg(&mut self, fraction_digits_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let fraction_digits_arg = fraction_digits_arg.token()?.clone();
        let fraction_digits_arg_built = FractionDigitsArg {
            fraction_digits_arg,
        };
        // Calling user action here
        self.user_grammar
            .fraction_digits_arg(&fraction_digits_arg_built)?;
        self.push(
            ASTType::FractionDigitsArg(fraction_digits_arg_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 436:
    ///
    /// `BitStmt: KwBit^ /* Clipped */ IdentifierArgStr BitStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt(
        &mut self,
        _kw_bit: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _bit_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let bit_stmt_suffix = pop_item!(self, bit_stmt_suffix, BitStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let bit_stmt_built = BitStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            bit_stmt_suffix: Box::new(bit_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.bit_stmt(&bit_stmt_built)?;
        self.push(ASTType::BitStmt(bit_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 437:
    ///
    /// `BitStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let bit_stmt_suffix_0_built = BitStmtSuffixSemicolon {};
        let bit_stmt_suffix_0_built = BitStmtSuffix::Semicolon(bit_stmt_suffix_0_built);
        self.push(ASTType::BitStmtSuffix(bit_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 438:
    ///
    /// `BitStmtSuffix: LBrace^ /* Clipped */ BitStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _bit_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let bit_stmt_list = pop_and_reverse_item!(self, bit_stmt_list, BitStmtList, context);
        self.pop(context);
        let bit_stmt_suffix_1_built = BitStmtSuffixLBraceBitStmtListRBrace { bit_stmt_list };
        let bit_stmt_suffix_1_built =
            BitStmtSuffix::LBraceBitStmtListRBrace(bit_stmt_suffix_1_built);
        self.push(ASTType::BitStmtSuffix(bit_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 439:
    ///
    /// `BitStmtList /* Vec<T>::Push */: BitStmtListGroup BitStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_list_0(
        &mut self,
        _bit_stmt_list_group: &ParseTreeType<'t>,
        _bit_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut bit_stmt_list = pop_item!(self, bit_stmt_list, BitStmtList, context);
        let bit_stmt_list_group = pop_item!(self, bit_stmt_list_group, BitStmtListGroup, context);
        let bit_stmt_list_0_built = BitStmtList {
            bit_stmt_list_group: Box::new(bit_stmt_list_group),
        };
        // Add an element to the vector
        bit_stmt_list.push(bit_stmt_list_0_built);
        self.push(ASTType::BitStmtList(bit_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 440:
    ///
    /// `BitStmtListGroup: PositionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_list_group_0(&mut self, _position_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let position_stmt = pop_item!(self, position_stmt, PositionStmt, context);
        let bit_stmt_list_group_0_built = BitStmtListGroupPositionStmt {
            position_stmt: Box::new(position_stmt),
        };
        let bit_stmt_list_group_0_built =
            BitStmtListGroup::PositionStmt(bit_stmt_list_group_0_built);
        self.push(
            ASTType::BitStmtListGroup(bit_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 441:
    ///
    /// `BitStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let bit_stmt_list_group_1_built = BitStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let bit_stmt_list_group_1_built =
            BitStmtListGroup::DescriptionStmt(bit_stmt_list_group_1_built);
        self.push(
            ASTType::BitStmtListGroup(bit_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 442:
    ///
    /// `BitStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_list_group_2(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let bit_stmt_list_group_2_built = BitStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let bit_stmt_list_group_2_built =
            BitStmtListGroup::ReferenceStmt(bit_stmt_list_group_2_built);
        self.push(
            ASTType::BitStmtListGroup(bit_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 443:
    ///
    /// `BitStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn bit_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let bit_stmt_list_1_built = Vec::new();
        self.push(ASTType::BitStmtList(bit_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 444:
    ///
    /// `PositionStmt: KwPosition^ /* Clipped */ IntegerValueStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn position_stmt(
        &mut self,
        _kw_position: &ParseTreeType<'t>,
        _integer_value_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let integer_value_str = pop_item!(self, integer_value_str, IntegerValueStr, context);
        self.pop(context);
        let position_stmt_built = PositionStmt {
            integer_value_str: Box::new(integer_value_str),
        };
        // Calling user action here
        self.user_grammar.position_stmt(&position_stmt_built)?;
        self.push(ASTType::PositionStmt(position_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 445:
    ///
    /// `LeafrefSpecification: PathStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leafref_specification_0(&mut self, _path_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let path_stmt = pop_item!(self, path_stmt, PathStmt, context);
        let leafref_specification_0_built = LeafrefSpecificationPathStmt {
            path_stmt: Box::new(path_stmt),
        };
        let leafref_specification_0_built =
            LeafrefSpecification::PathStmt(leafref_specification_0_built);
        // Calling user action here
        self.user_grammar
            .leafref_specification(&leafref_specification_0_built)?;
        self.push(
            ASTType::LeafrefSpecification(leafref_specification_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 446:
    ///
    /// `LeafrefSpecification: RequireInstanceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn leafref_specification_1(
        &mut self,
        _require_instance_stmt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let require_instance_stmt =
            pop_item!(self, require_instance_stmt, RequireInstanceStmt, context);
        let leafref_specification_1_built = LeafrefSpecificationRequireInstanceStmt {
            require_instance_stmt: Box::new(require_instance_stmt),
        };
        let leafref_specification_1_built =
            LeafrefSpecification::RequireInstanceStmt(leafref_specification_1_built);
        // Calling user action here
        self.user_grammar
            .leafref_specification(&leafref_specification_1_built)?;
        self.push(
            ASTType::LeafrefSpecification(leafref_specification_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 447:
    ///
    /// `RequireInstanceStmt: KwRequireInstance^ /* Clipped */ RequireInstanceArgStr Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn require_instance_stmt(
        &mut self,
        _kw_require_instance: &ParseTreeType<'t>,
        _require_instance_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let require_instance_arg_str = pop_item!(
            self,
            require_instance_arg_str,
            RequireInstanceArgStr,
            context
        );
        self.pop(context);
        let require_instance_stmt_built = RequireInstanceStmt {
            require_instance_arg_str: Box::new(require_instance_arg_str),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar
            .require_instance_stmt(&require_instance_stmt_built)?;
        self.push(
            ASTType::RequireInstanceStmt(require_instance_stmt_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 448:
    ///
    /// `RequireInstanceArgStr: MandatoryArg;`
    ///
    #[parol_runtime::function_name::named]
    fn require_instance_arg_str_0(&mut self, _mandatory_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mandatory_arg = pop_item!(self, mandatory_arg, MandatoryArg, context);
        let require_instance_arg_str_0_built = RequireInstanceArgStrMandatoryArg {
            mandatory_arg: Box::new(mandatory_arg),
        };
        let require_instance_arg_str_0_built =
            RequireInstanceArgStr::MandatoryArg(require_instance_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .require_instance_arg_str(&require_instance_arg_str_0_built)?;
        self.push(
            ASTType::RequireInstanceArgStr(require_instance_arg_str_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 449:
    ///
    /// `RequireInstanceArgStr: <Mandatory>'"' MandatoryArg <Mandatory>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn require_instance_arg_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _mandatory_arg: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let mandatory_arg = pop_item!(self, mandatory_arg, MandatoryArg, context);
        let require_instance_arg_str_1_built =
            RequireInstanceArgStrDoubleQuotationMandatoryArgDoubleQuotation {
                double_quotation,
                mandatory_arg: Box::new(mandatory_arg),
                double_quotation0,
            };
        let require_instance_arg_str_1_built =
            RequireInstanceArgStr::DoubleQuotationMandatoryArgDoubleQuotation(
                require_instance_arg_str_1_built,
            );
        // Calling user action here
        self.user_grammar
            .require_instance_arg_str(&require_instance_arg_str_1_built)?;
        self.push(
            ASTType::RequireInstanceArgStr(require_instance_arg_str_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 450:
    ///
    /// `PathStmt: 'path'^ /* Clipped */ Ystring Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn path_stmt(
        &mut self,
        _path: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let path_stmt_built = PathStmt {
            ystring: Box::new(ystring),
        };
        // Calling user action here
        self.user_grammar.path_stmt(&path_stmt_built)?;
        self.push(ASTType::PathStmt(path_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 451:
    ///
    /// `StringRestrictions: LengthStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn string_restrictions_0(&mut self, _length_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let length_stmt = pop_item!(self, length_stmt, LengthStmt, context);
        let string_restrictions_0_built = StringRestrictionsLengthStmt {
            length_stmt: Box::new(length_stmt),
        };
        let string_restrictions_0_built =
            StringRestrictions::LengthStmt(string_restrictions_0_built);
        // Calling user action here
        self.user_grammar
            .string_restrictions(&string_restrictions_0_built)?;
        self.push(
            ASTType::StringRestrictions(string_restrictions_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 452:
    ///
    /// `StringRestrictions: PatternStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn string_restrictions_1(&mut self, _pattern_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let pattern_stmt = pop_item!(self, pattern_stmt, PatternStmt, context);
        let string_restrictions_1_built = StringRestrictionsPatternStmt {
            pattern_stmt: Box::new(pattern_stmt),
        };
        let string_restrictions_1_built =
            StringRestrictions::PatternStmt(string_restrictions_1_built);
        // Calling user action here
        self.user_grammar
            .string_restrictions(&string_restrictions_1_built)?;
        self.push(
            ASTType::StringRestrictions(string_restrictions_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 453:
    ///
    /// `PatternStmt: 'pattern' Ystring Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn pattern_stmt(
        &mut self,
        pattern: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let pattern = pattern.token()?.clone();
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let pattern_stmt_built = PatternStmt {
            pattern,
            ystring: Box::new(ystring),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.pattern_stmt(&pattern_stmt_built)?;
        self.push(ASTType::PatternStmt(pattern_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 454:
    ///
    /// `LengthStmt: KwLength^ /* Clipped */ RangeArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn length_stmt(
        &mut self,
        _kw_length: &ParseTreeType<'t>,
        _range_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let range_arg_str = pop_item!(self, range_arg_str, RangeArgStr, context);
        self.pop(context);
        let length_stmt_built = LengthStmt {
            range_arg_str: Box::new(range_arg_str),
        };
        // Calling user action here
        self.user_grammar.length_stmt(&length_stmt_built)?;
        self.push(ASTType::LengthStmt(length_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 455:
    ///
    /// `EnumStmt: KwEnum^ /* Clipped */ EnumArgStr EnumStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt(
        &mut self,
        _kw_enum: &ParseTreeType<'t>,
        _enum_arg_str: &ParseTreeType<'t>,
        _enum_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let enum_stmt_suffix = pop_item!(self, enum_stmt_suffix, EnumStmtSuffix, context);
        let enum_arg_str = pop_item!(self, enum_arg_str, EnumArgStr, context);
        self.pop(context);
        let enum_stmt_built = EnumStmt {
            enum_arg_str: Box::new(enum_arg_str),
            enum_stmt_suffix: Box::new(enum_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.enum_stmt(&enum_stmt_built)?;
        self.push(ASTType::EnumStmt(enum_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 456:
    ///
    /// `EnumStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let enum_stmt_suffix_0_built = EnumStmtSuffixSemicolon {};
        let enum_stmt_suffix_0_built = EnumStmtSuffix::Semicolon(enum_stmt_suffix_0_built);
        self.push(ASTType::EnumStmtSuffix(enum_stmt_suffix_0_built), context);
        Ok(())
    }

    /// Semantic action for production 457:
    ///
    /// `EnumStmtSuffix: LBrace^ /* Clipped */ EnumStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _enum_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let enum_stmt_list = pop_and_reverse_item!(self, enum_stmt_list, EnumStmtList, context);
        self.pop(context);
        let enum_stmt_suffix_1_built = EnumStmtSuffixLBraceEnumStmtListRBrace { enum_stmt_list };
        let enum_stmt_suffix_1_built =
            EnumStmtSuffix::LBraceEnumStmtListRBrace(enum_stmt_suffix_1_built);
        self.push(ASTType::EnumStmtSuffix(enum_stmt_suffix_1_built), context);
        Ok(())
    }

    /// Semantic action for production 458:
    ///
    /// `EnumStmtList /* Vec<T>::Push */: EnumStmtListGroup EnumStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_0(
        &mut self,
        _enum_stmt_list_group: &ParseTreeType<'t>,
        _enum_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut enum_stmt_list = pop_item!(self, enum_stmt_list, EnumStmtList, context);
        let enum_stmt_list_group =
            pop_item!(self, enum_stmt_list_group, EnumStmtListGroup, context);
        let enum_stmt_list_0_built = EnumStmtList {
            enum_stmt_list_group: Box::new(enum_stmt_list_group),
        };
        // Add an element to the vector
        enum_stmt_list.push(enum_stmt_list_0_built);
        self.push(ASTType::EnumStmtList(enum_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 459:
    ///
    /// `EnumStmtListGroup: IfFeatureStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_group_0(&mut self, _if_feature_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let if_feature_stmt = pop_item!(self, if_feature_stmt, IfFeatureStmt, context);
        let enum_stmt_list_group_0_built = EnumStmtListGroupIfFeatureStmt {
            if_feature_stmt: Box::new(if_feature_stmt),
        };
        let enum_stmt_list_group_0_built =
            EnumStmtListGroup::IfFeatureStmt(enum_stmt_list_group_0_built);
        self.push(
            ASTType::EnumStmtListGroup(enum_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 460:
    ///
    /// `EnumStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let enum_stmt_list_group_1_built = EnumStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let enum_stmt_list_group_1_built =
            EnumStmtListGroup::DescriptionStmt(enum_stmt_list_group_1_built);
        self.push(
            ASTType::EnumStmtListGroup(enum_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 461:
    ///
    /// `EnumStmtListGroup: ValueStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_group_2(&mut self, _value_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value_stmt = pop_item!(self, value_stmt, ValueStmt, context);
        let enum_stmt_list_group_2_built = EnumStmtListGroupValueStmt {
            value_stmt: Box::new(value_stmt),
        };
        let enum_stmt_list_group_2_built =
            EnumStmtListGroup::ValueStmt(enum_stmt_list_group_2_built);
        self.push(
            ASTType::EnumStmtListGroup(enum_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 462:
    ///
    /// `EnumStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let enum_stmt_list_group_3_built = EnumStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let enum_stmt_list_group_3_built =
            EnumStmtListGroup::ReferenceStmt(enum_stmt_list_group_3_built);
        self.push(
            ASTType::EnumStmtListGroup(enum_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 463:
    ///
    /// `EnumStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let enum_stmt_list_1_built = Vec::new();
        self.push(ASTType::EnumStmtList(enum_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 464:
    ///
    /// `ValueStmt: KwValue^ /* Clipped */ IntegerValueStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn value_stmt(
        &mut self,
        _kw_value: &ParseTreeType<'t>,
        _integer_value_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let integer_value_str = pop_item!(self, integer_value_str, IntegerValueStr, context);
        self.pop(context);
        let value_stmt_built = ValueStmt {
            integer_value_str: Box::new(integer_value_str),
        };
        // Calling user action here
        self.user_grammar.value_stmt(&value_stmt_built)?;
        self.push(ASTType::ValueStmt(value_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 465:
    ///
    /// `IntegerValueStr: IntegerValue;`
    ///
    #[parol_runtime::function_name::named]
    fn integer_value_str_0(&mut self, _integer_value: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer_value = pop_item!(self, integer_value, IntegerValue, context);
        let integer_value_str_0_built = IntegerValueStrIntegerValue {
            integer_value: Box::new(integer_value),
        };
        let integer_value_str_0_built = IntegerValueStr::IntegerValue(integer_value_str_0_built);
        // Calling user action here
        self.user_grammar
            .integer_value_str(&integer_value_str_0_built)?;
        self.push(ASTType::IntegerValueStr(integer_value_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 466:
    ///
    /// `IntegerValueStr: <Value>'"' IntegerValue <Value>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn integer_value_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _integer_value: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let integer_value = pop_item!(self, integer_value, IntegerValue, context);
        let integer_value_str_1_built = IntegerValueStrDoubleQuotationIntegerValueDoubleQuotation {
            double_quotation,
            integer_value: Box::new(integer_value),
            double_quotation0,
        };
        let integer_value_str_1_built =
            IntegerValueStr::DoubleQuotationIntegerValueDoubleQuotation(integer_value_str_1_built);
        // Calling user action here
        self.user_grammar
            .integer_value_str(&integer_value_str_1_built)?;
        self.push(ASTType::IntegerValueStr(integer_value_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 467:
    ///
    /// `IntegerValue: <Value>/[0-9]+/;`
    ///
    #[parol_runtime::function_name::named]
    fn integer_value(&mut self, integer_value: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer_value = integer_value.token()?.clone();
        let integer_value_built = IntegerValue { integer_value };
        // Calling user action here
        self.user_grammar.integer_value(&integer_value_built)?;
        self.push(ASTType::IntegerValue(integer_value_built), context);
        Ok(())
    }

    /// Semantic action for production 468:
    ///
    /// `EnumArgStr: AsciiNoBrace;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_arg_str_0(&mut self, _ascii_no_brace: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ascii_no_brace = pop_item!(self, ascii_no_brace, AsciiNoBrace, context);
        let enum_arg_str_0_built = EnumArgStrAsciiNoBrace {
            ascii_no_brace: Box::new(ascii_no_brace),
        };
        let enum_arg_str_0_built = EnumArgStr::AsciiNoBrace(enum_arg_str_0_built);
        // Calling user action here
        self.user_grammar.enum_arg_str(&enum_arg_str_0_built)?;
        self.push(ASTType::EnumArgStr(enum_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 469:
    ///
    /// `EnumArgStr: <Enum>'"'^ /* Clipped */ AsciiNoBrace <Enum>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn enum_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _ascii_no_brace: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ascii_no_brace = pop_item!(self, ascii_no_brace, AsciiNoBrace, context);
        let enum_arg_str_1_built = EnumArgStrDoubleQuotationAsciiNoBraceDoubleQuotation {
            ascii_no_brace: Box::new(ascii_no_brace),
        };
        let enum_arg_str_1_built =
            EnumArgStr::DoubleQuotationAsciiNoBraceDoubleQuotation(enum_arg_str_1_built);
        // Calling user action here
        self.user_grammar.enum_arg_str(&enum_arg_str_1_built)?;
        self.push(ASTType::EnumArgStr(enum_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 470:
    ///
    /// `RangeStmt: KwRange^ /* Clipped */ RangeArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn range_stmt(
        &mut self,
        _kw_range: &ParseTreeType<'t>,
        _range_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let range_arg_str = pop_item!(self, range_arg_str, RangeArgStr, context);
        self.pop(context);
        let range_stmt_built = RangeStmt {
            range_arg_str: Box::new(range_arg_str),
        };
        // Calling user action here
        self.user_grammar.range_stmt(&range_stmt_built)?;
        self.push(ASTType::RangeStmt(range_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 471:
    ///
    /// `RangeArgStr: RangeArg;`
    ///
    #[parol_runtime::function_name::named]
    fn range_arg_str_0(&mut self, _range_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let range_arg = pop_item!(self, range_arg, RangeArg, context);
        let range_arg_str_0_built = RangeArgStrRangeArg {
            range_arg: Box::new(range_arg),
        };
        let range_arg_str_0_built = RangeArgStr::RangeArg(range_arg_str_0_built);
        // Calling user action here
        self.user_grammar.range_arg_str(&range_arg_str_0_built)?;
        self.push(ASTType::RangeArgStr(range_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 472:
    ///
    /// `RangeArgStr: <Range>'"'^ /* Clipped */ RangeArg <Range>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn range_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _range_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let range_arg = pop_item!(self, range_arg, RangeArg, context);
        let range_arg_str_1_built = RangeArgStrDoubleQuotationRangeArgDoubleQuotation {
            range_arg: Box::new(range_arg),
        };
        let range_arg_str_1_built =
            RangeArgStr::DoubleQuotationRangeArgDoubleQuotation(range_arg_str_1_built);
        // Calling user action here
        self.user_grammar.range_arg_str(&range_arg_str_1_built)?;
        self.push(ASTType::RangeArgStr(range_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 473:
    ///
    /// `RangeArg: RangePart RangeArgOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn range_arg(
        &mut self,
        _range_part: &ParseTreeType<'t>,
        _range_arg_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let range_arg_opt = pop_item!(self, range_arg_opt, RangeArgOpt, context);
        let range_part = pop_item!(self, range_part, RangePart, context);
        let range_arg_built = RangeArg {
            range_part: Box::new(range_part),
            range_arg_opt,
        };
        // Calling user action here
        self.user_grammar.range_arg(&range_arg_built)?;
        self.push(ASTType::RangeArg(range_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 474:
    ///
    /// `RangeArgOpt /* Option<T>::Some */: <Range>'|' RangeArg;`
    ///
    #[parol_runtime::function_name::named]
    fn range_arg_opt_0(
        &mut self,
        or: &ParseTreeType<'t>,
        _range_arg: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let or = or.token()?.clone();
        let range_arg = pop_item!(self, range_arg, RangeArg, context);
        let range_arg_opt_0_built = RangeArgOpt {
            or,
            range_arg: Box::new(range_arg),
        };
        self.push(ASTType::RangeArgOpt(Some(range_arg_opt_0_built)), context);
        Ok(())
    }

    /// Semantic action for production 475:
    ///
    /// `RangeArgOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn range_arg_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::RangeArgOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 476:
    ///
    /// `RangePart: RangeBoundary RangePartOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn range_part(
        &mut self,
        _range_boundary: &ParseTreeType<'t>,
        _range_part_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let range_part_opt = pop_item!(self, range_part_opt, RangePartOpt, context);
        let range_boundary = pop_item!(self, range_boundary, RangeBoundary, context);
        let range_part_built = RangePart {
            range_boundary: Box::new(range_boundary),
            range_part_opt,
        };
        // Calling user action here
        self.user_grammar.range_part(&range_part_built)?;
        self.push(ASTType::RangePart(range_part_built), context);
        Ok(())
    }

    /// Semantic action for production 477:
    ///
    /// `RangePartOpt /* Option<T>::Some */: <Range>'..' RangeBoundary;`
    ///
    #[parol_runtime::function_name::named]
    fn range_part_opt_0(
        &mut self,
        dot_dot: &ParseTreeType<'t>,
        _range_boundary: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let dot_dot = dot_dot.token()?.clone();
        let range_boundary = pop_item!(self, range_boundary, RangeBoundary, context);
        let range_part_opt_0_built = RangePartOpt {
            dot_dot,
            range_boundary: Box::new(range_boundary),
        };
        self.push(ASTType::RangePartOpt(Some(range_part_opt_0_built)), context);
        Ok(())
    }

    /// Semantic action for production 478:
    ///
    /// `RangePartOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn range_part_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::RangePartOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 479:
    ///
    /// `RangeBoundary: <Range>'min';`
    ///
    #[parol_runtime::function_name::named]
    fn range_boundary_0(&mut self, min: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let min = min.token()?.clone();
        let range_boundary_0_built = RangeBoundaryMin { min };
        let range_boundary_0_built = RangeBoundary::Min(range_boundary_0_built);
        // Calling user action here
        self.user_grammar.range_boundary(&range_boundary_0_built)?;
        self.push(ASTType::RangeBoundary(range_boundary_0_built), context);
        Ok(())
    }

    /// Semantic action for production 480:
    ///
    /// `RangeBoundary: <Range>'max';`
    ///
    #[parol_runtime::function_name::named]
    fn range_boundary_1(&mut self, max: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let max = max.token()?.clone();
        let range_boundary_1_built = RangeBoundaryMax { max };
        let range_boundary_1_built = RangeBoundary::Max(range_boundary_1_built);
        // Calling user action here
        self.user_grammar.range_boundary(&range_boundary_1_built)?;
        self.push(ASTType::RangeBoundary(range_boundary_1_built), context);
        Ok(())
    }

    /// Semantic action for production 481:
    ///
    /// `RangeBoundary: <Range>"-?[0-9]+";`
    ///
    #[parol_runtime::function_name::named]
    fn range_boundary_2(
        &mut self,
        minus_quest_l_bracket0_minus9_r_bracket_plus: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let minus_quest_l_bracket0_minus9_r_bracket_plus =
            minus_quest_l_bracket0_minus9_r_bracket_plus
                .token()?
                .clone();
        let range_boundary_2_built = RangeBoundaryMinusQuestLBracket0Minus9RBracketPlus {
            minus_quest_l_bracket0_minus9_r_bracket_plus,
        };
        let range_boundary_2_built =
            RangeBoundary::MinusQuestLBracket0Minus9RBracketPlus(range_boundary_2_built);
        // Calling user action here
        self.user_grammar.range_boundary(&range_boundary_2_built)?;
        self.push(ASTType::RangeBoundary(range_boundary_2_built), context);
        Ok(())
    }

    /// Semantic action for production 482:
    ///
    /// `IdentifierRefArgStr: IdentifierRef;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_ref_arg_str_0(&mut self, _identifier_ref: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let identifier_ref_arg_str_0_built = IdentifierRefArgStrIdentifierRef {
            identifier_ref: Box::new(identifier_ref),
        };
        let identifier_ref_arg_str_0_built =
            IdentifierRefArgStr::IdentifierRef(identifier_ref_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .identifier_ref_arg_str(&identifier_ref_arg_str_0_built)?;
        self.push(
            ASTType::IdentifierRefArgStr(identifier_ref_arg_str_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 483:
    ///
    /// `IdentifierRefArgStr: <Keyword, IfFeature>'"' IdentifierRef <Keyword, IfFeature>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_ref_arg_str_1(
        &mut self,
        double_quotation: &ParseTreeType<'t>,
        _identifier_ref: &ParseTreeType<'t>,
        double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation0 = double_quotation0.token()?.clone();
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let identifier_ref_arg_str_1_built =
            IdentifierRefArgStrDoubleQuotationIdentifierRefDoubleQuotation {
                double_quotation,
                identifier_ref: Box::new(identifier_ref),
                double_quotation0,
            };
        let identifier_ref_arg_str_1_built =
            IdentifierRefArgStr::DoubleQuotationIdentifierRefDoubleQuotation(
                identifier_ref_arg_str_1_built,
            );
        // Calling user action here
        self.user_grammar
            .identifier_ref_arg_str(&identifier_ref_arg_str_1_built)?;
        self.push(
            ASTType::IdentifierRefArgStr(identifier_ref_arg_str_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 484:
    ///
    /// `IdentifierRef: IdentifierRefOpt /* Option */ Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_ref(
        &mut self,
        _identifier_ref_opt: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_ref_opt = pop_item!(self, identifier_ref_opt, IdentifierRefOpt, context);
        let identifier_ref_built = IdentifierRef {
            identifier_ref_opt,
            identifier: Box::new(identifier),
        };
        // Calling user action here
        self.user_grammar.identifier_ref(&identifier_ref_built)?;
        self.push(ASTType::IdentifierRef(identifier_ref_built), context);
        Ok(())
    }

    /// Semantic action for production 485:
    ///
    /// `IdentifierRefOpt /* Option<T>::Some */: Identifier <Keyword, IfFeature>':';`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_ref_opt_0(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        colon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let colon = colon.token()?.clone();
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_ref_opt_0_built = IdentifierRefOpt {
            identifier: Box::new(identifier),
            colon,
        };
        self.push(
            ASTType::IdentifierRefOpt(Some(identifier_ref_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 486:
    ///
    /// `IdentifierRefOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_ref_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::IdentifierRefOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 487:
    ///
    /// `KeyStmt: KwKey^ /* Clipped */ KeyArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn key_stmt(
        &mut self,
        _kw_key: &ParseTreeType<'t>,
        _key_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let key_arg_str = pop_item!(self, key_arg_str, KeyArgStr, context);
        self.pop(context);
        let key_stmt_built = KeyStmt {
            key_arg_str: Box::new(key_arg_str),
        };
        // Calling user action here
        self.user_grammar.key_stmt(&key_stmt_built)?;
        self.push(ASTType::KeyStmt(key_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 488:
    ///
    /// `KeyArgStr: KeyArg;`
    ///
    #[parol_runtime::function_name::named]
    fn key_arg_str_0(&mut self, _key_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_arg = pop_item!(self, key_arg, KeyArg, context);
        let key_arg_str_0_built = KeyArgStrKeyArg {
            key_arg: Box::new(key_arg),
        };
        let key_arg_str_0_built = KeyArgStr::KeyArg(key_arg_str_0_built);
        // Calling user action here
        self.user_grammar.key_arg_str(&key_arg_str_0_built)?;
        self.push(ASTType::KeyArgStr(key_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 489:
    ///
    /// `KeyArgStr: <Keyword>'"'^ /* Clipped */ KeyArg <Keyword>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn key_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _key_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_arg = pop_item!(self, key_arg, KeyArg, context);
        let key_arg_str_1_built = KeyArgStrDoubleQuotationKeyArgDoubleQuotation {
            key_arg: Box::new(key_arg),
        };
        let key_arg_str_1_built =
            KeyArgStr::DoubleQuotationKeyArgDoubleQuotation(key_arg_str_1_built);
        // Calling user action here
        self.user_grammar.key_arg_str(&key_arg_str_1_built)?;
        self.push(ASTType::KeyArgStr(key_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 490:
    ///
    /// `Semicolon: <INITIAL, Keyword, YVersion, Range, Enum, Default, Revision, Mandatory, IfFeature, Status, Value, Fraction, Ordered, Uri>';';`
    ///
    #[parol_runtime::function_name::named]
    fn semicolon(&mut self, semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = semicolon.token()?.clone();
        let semicolon_built = Semicolon { semicolon };
        // Calling user action here
        self.user_grammar.semicolon(&semicolon_built)?;
        self.push(ASTType::Semicolon(semicolon_built), context);
        Ok(())
    }

    /// Semantic action for production 491:
    ///
    /// `KeyArg: IdentifierRef KeyArgOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn key_arg(
        &mut self,
        _identifier_ref: &ParseTreeType<'t>,
        _key_arg_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_arg_opt = pop_item!(self, key_arg_opt, KeyArgOpt, context);
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let key_arg_built = KeyArg {
            identifier_ref: Box::new(identifier_ref),
            key_arg_opt,
        };
        // Calling user action here
        self.user_grammar.key_arg(&key_arg_built)?;
        self.push(ASTType::KeyArg(key_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 492:
    ///
    /// `KeyArgOpt /* Option<T>::Some */: KeyArg;`
    ///
    #[parol_runtime::function_name::named]
    fn key_arg_opt_0(&mut self, _key_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_arg = pop_item!(self, key_arg, KeyArg, context);
        let key_arg_opt_0_built = KeyArgOpt {
            key_arg: Box::new(key_arg),
        };
        self.push(ASTType::KeyArgOpt(Some(key_arg_opt_0_built)), context);
        Ok(())
    }

    /// Semantic action for production 493:
    ///
    /// `KeyArgOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn key_arg_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::KeyArgOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 494:
    ///
    /// `AbsoluteSchemaNodeid: <Keyword, IfFeature>'/' IdentifierRef;`
    ///
    #[parol_runtime::function_name::named]
    fn absolute_schema_nodeid(
        &mut self,
        slash: &ParseTreeType<'t>,
        _identifier_ref: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let slash = slash.token()?.clone();
        let identifier_ref = pop_item!(self, identifier_ref, IdentifierRef, context);
        let absolute_schema_nodeid_built = AbsoluteSchemaNodeid {
            slash,
            identifier_ref: Box::new(identifier_ref),
        };
        // Calling user action here
        self.user_grammar
            .absolute_schema_nodeid(&absolute_schema_nodeid_built)?;
        self.push(
            ASTType::AbsoluteSchemaNodeid(absolute_schema_nodeid_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 495:
    ///
    /// `ImportStmt: KwImport^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ ImportStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt(
        &mut self,
        _kw_import: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _import_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let import_stmt_list =
            pop_and_reverse_item!(self, import_stmt_list, ImportStmtList, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let import_stmt_built = ImportStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            import_stmt_list,
        };
        // Calling user action here
        self.user_grammar.import_stmt(&import_stmt_built)?;
        self.push(ASTType::ImportStmt(import_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 496:
    ///
    /// `ImportStmtList /* Vec<T>::Push */: ImportStmtListGroup ImportStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_0(
        &mut self,
        _import_stmt_list_group: &ParseTreeType<'t>,
        _import_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut import_stmt_list = pop_item!(self, import_stmt_list, ImportStmtList, context);
        let import_stmt_list_group =
            pop_item!(self, import_stmt_list_group, ImportStmtListGroup, context);
        let import_stmt_list_0_built = ImportStmtList {
            import_stmt_list_group: Box::new(import_stmt_list_group),
        };
        // Add an element to the vector
        import_stmt_list.push(import_stmt_list_0_built);
        self.push(ASTType::ImportStmtList(import_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 497:
    ///
    /// `ImportStmtListGroup: PrefixStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_group_0(&mut self, _prefix_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prefix_stmt = pop_item!(self, prefix_stmt, PrefixStmt, context);
        let import_stmt_list_group_0_built = ImportStmtListGroupPrefixStmt {
            prefix_stmt: Box::new(prefix_stmt),
        };
        let import_stmt_list_group_0_built =
            ImportStmtListGroup::PrefixStmt(import_stmt_list_group_0_built);
        self.push(
            ASTType::ImportStmtListGroup(import_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 498:
    ///
    /// `ImportStmtListGroup: RevisionDateStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_group_1(&mut self, _revision_date_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let revision_date_stmt = pop_item!(self, revision_date_stmt, RevisionDateStmt, context);
        let import_stmt_list_group_1_built = ImportStmtListGroupRevisionDateStmt {
            revision_date_stmt: Box::new(revision_date_stmt),
        };
        let import_stmt_list_group_1_built =
            ImportStmtListGroup::RevisionDateStmt(import_stmt_list_group_1_built);
        self.push(
            ASTType::ImportStmtListGroup(import_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 499:
    ///
    /// `ImportStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_group_2(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let import_stmt_list_group_2_built = ImportStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let import_stmt_list_group_2_built =
            ImportStmtListGroup::DescriptionStmt(import_stmt_list_group_2_built);
        self.push(
            ASTType::ImportStmtListGroup(import_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 500:
    ///
    /// `ImportStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_group_3(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let import_stmt_list_group_3_built = ImportStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let import_stmt_list_group_3_built =
            ImportStmtListGroup::ReferenceStmt(import_stmt_list_group_3_built);
        self.push(
            ASTType::ImportStmtListGroup(import_stmt_list_group_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 501:
    ///
    /// `ImportStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn import_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let import_stmt_list_1_built = Vec::new();
        self.push(ASTType::ImportStmtList(import_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 502:
    ///
    /// `IncludeStmt: KwInclude^ /* Clipped */ IdentifierArgStr IncludeStmtSuffix;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt(
        &mut self,
        _kw_include: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _include_stmt_suffix: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let include_stmt_suffix = pop_item!(self, include_stmt_suffix, IncludeStmtSuffix, context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let include_stmt_built = IncludeStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            include_stmt_suffix: Box::new(include_stmt_suffix),
        };
        // Calling user action here
        self.user_grammar.include_stmt(&include_stmt_built)?;
        self.push(ASTType::IncludeStmt(include_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 503:
    ///
    /// `IncludeStmtSuffix: Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_suffix_0(&mut self, _semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let include_stmt_suffix_0_built = IncludeStmtSuffixSemicolon {};
        let include_stmt_suffix_0_built = IncludeStmtSuffix::Semicolon(include_stmt_suffix_0_built);
        self.push(
            ASTType::IncludeStmtSuffix(include_stmt_suffix_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 504:
    ///
    /// `IncludeStmtSuffix: LBrace^ /* Clipped */ IncludeStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_suffix_1(
        &mut self,
        _l_brace: &ParseTreeType<'t>,
        _include_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let include_stmt_list =
            pop_and_reverse_item!(self, include_stmt_list, IncludeStmtList, context);
        self.pop(context);
        let include_stmt_suffix_1_built =
            IncludeStmtSuffixLBraceIncludeStmtListRBrace { include_stmt_list };
        let include_stmt_suffix_1_built =
            IncludeStmtSuffix::LBraceIncludeStmtListRBrace(include_stmt_suffix_1_built);
        self.push(
            ASTType::IncludeStmtSuffix(include_stmt_suffix_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 505:
    ///
    /// `IncludeStmtList /* Vec<T>::Push */: IncludeStmtListGroup IncludeStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_list_0(
        &mut self,
        _include_stmt_list_group: &ParseTreeType<'t>,
        _include_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut include_stmt_list = pop_item!(self, include_stmt_list, IncludeStmtList, context);
        let include_stmt_list_group =
            pop_item!(self, include_stmt_list_group, IncludeStmtListGroup, context);
        let include_stmt_list_0_built = IncludeStmtList {
            include_stmt_list_group: Box::new(include_stmt_list_group),
        };
        // Add an element to the vector
        include_stmt_list.push(include_stmt_list_0_built);
        self.push(ASTType::IncludeStmtList(include_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 506:
    ///
    /// `IncludeStmtListGroup: RevisionDateStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_list_group_0(&mut self, _revision_date_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let revision_date_stmt = pop_item!(self, revision_date_stmt, RevisionDateStmt, context);
        let include_stmt_list_group_0_built = IncludeStmtListGroupRevisionDateStmt {
            revision_date_stmt: Box::new(revision_date_stmt),
        };
        let include_stmt_list_group_0_built =
            IncludeStmtListGroup::RevisionDateStmt(include_stmt_list_group_0_built);
        self.push(
            ASTType::IncludeStmtListGroup(include_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 507:
    ///
    /// `IncludeStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_list_group_1(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let include_stmt_list_group_1_built = IncludeStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let include_stmt_list_group_1_built =
            IncludeStmtListGroup::DescriptionStmt(include_stmt_list_group_1_built);
        self.push(
            ASTType::IncludeStmtListGroup(include_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 508:
    ///
    /// `IncludeStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_list_group_2(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let include_stmt_list_group_2_built = IncludeStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let include_stmt_list_group_2_built =
            IncludeStmtListGroup::ReferenceStmt(include_stmt_list_group_2_built);
        self.push(
            ASTType::IncludeStmtListGroup(include_stmt_list_group_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 509:
    ///
    /// `IncludeStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn include_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let include_stmt_list_1_built = Vec::new();
        self.push(ASTType::IncludeStmtList(include_stmt_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 510:
    ///
    /// `RevisionDateStmt: KwRevisionDate^ /* Clipped */ DateArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_date_stmt(
        &mut self,
        _kw_revision_date: &ParseTreeType<'t>,
        _date_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let date_arg_str = pop_item!(self, date_arg_str, DateArgStr, context);
        self.pop(context);
        let revision_date_stmt_built = RevisionDateStmt {
            date_arg_str: Box::new(date_arg_str),
        };
        // Calling user action here
        self.user_grammar
            .revision_date_stmt(&revision_date_stmt_built)?;
        self.push(ASTType::RevisionDateStmt(revision_date_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 511:
    ///
    /// `NamespaceStmt: KwNamespace^ /* Clipped */ UriStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn namespace_stmt(
        &mut self,
        _kw_namespace: &ParseTreeType<'t>,
        _uri_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let uri_str = pop_item!(self, uri_str, UriStr, context);
        self.pop(context);
        let namespace_stmt_built = NamespaceStmt {
            uri_str: Box::new(uri_str),
        };
        // Calling user action here
        self.user_grammar.namespace_stmt(&namespace_stmt_built)?;
        self.push(ASTType::NamespaceStmt(namespace_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 512:
    ///
    /// `UriStr: UriArg;`
    ///
    #[parol_runtime::function_name::named]
    fn uri_str_0(&mut self, _uri_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uri_arg = pop_item!(self, uri_arg, UriArg, context);
        let uri_str_0_built = UriStrUriArg {
            uri_arg: Box::new(uri_arg),
        };
        let uri_str_0_built = UriStr::UriArg(uri_str_0_built);
        // Calling user action here
        self.user_grammar.uri_str(&uri_str_0_built)?;
        self.push(ASTType::UriStr(uri_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 513:
    ///
    /// `UriStr: <Uri>'"'^ /* Clipped */ UriArg <Uri>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn uri_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _uri_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uri_arg = pop_item!(self, uri_arg, UriArg, context);
        let uri_str_1_built = UriStrDoubleQuotationUriArgDoubleQuotation {
            uri_arg: Box::new(uri_arg),
        };
        let uri_str_1_built = UriStr::DoubleQuotationUriArgDoubleQuotation(uri_str_1_built);
        // Calling user action here
        self.user_grammar.uri_str(&uri_str_1_built)?;
        self.push(ASTType::UriStr(uri_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 514:
    ///
    /// `UriArg: <Uri>"urn:[a-zA-Z0-9\-\.:]+";`
    ///
    #[parol_runtime::function_name::named]
    fn uri_arg(&mut self, uri_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let uri_arg = uri_arg.token()?.clone();
        let uri_arg_built = UriArg { uri_arg };
        // Calling user action here
        self.user_grammar.uri_arg(&uri_arg_built)?;
        self.push(ASTType::UriArg(uri_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 515:
    ///
    /// `PrefixStmt: KwPrefix^ /* Clipped */ IdentifierArgStr Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn prefix_stmt(
        &mut self,
        _kw_prefix: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let prefix_stmt_built = PrefixStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
        };
        // Calling user action here
        self.user_grammar.prefix_stmt(&prefix_stmt_built)?;
        self.push(ASTType::PrefixStmt(prefix_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 516:
    ///
    /// `BelongsToStmt: KwBelongsTo^ /* Clipped */ IdentifierArgStr LBrace^ /* Clipped */ PrefixStmt '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn belongs_to_stmt(
        &mut self,
        _kw_belongs_to: &ParseTreeType<'t>,
        _identifier_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _prefix_stmt: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prefix_stmt = pop_item!(self, prefix_stmt, PrefixStmt, context);
        self.pop(context);
        let identifier_arg_str = pop_item!(self, identifier_arg_str, IdentifierArgStr, context);
        self.pop(context);
        let belongs_to_stmt_built = BelongsToStmt {
            identifier_arg_str: Box::new(identifier_arg_str),
            prefix_stmt: Box::new(prefix_stmt),
        };
        // Calling user action here
        self.user_grammar.belongs_to_stmt(&belongs_to_stmt_built)?;
        self.push(ASTType::BelongsToStmt(belongs_to_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 517:
    ///
    /// `OrganizationStmt: 'organization'^ /* Clipped */ Ystring Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn organization_stmt(
        &mut self,
        _organization: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let organization_stmt_built = OrganizationStmt {
            ystring: Box::new(ystring),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar
            .organization_stmt(&organization_stmt_built)?;
        self.push(ASTType::OrganizationStmt(organization_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 518:
    ///
    /// `ContactStmt: 'contact'^ /* Clipped */ Ystring Semicolon;`
    ///
    #[parol_runtime::function_name::named]
    fn contact_stmt(
        &mut self,
        _contact: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = pop_item!(self, semicolon, Semicolon, context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let contact_stmt_built = ContactStmt {
            ystring: Box::new(ystring),
            semicolon: Box::new(semicolon),
        };
        // Calling user action here
        self.user_grammar.contact_stmt(&contact_stmt_built)?;
        self.push(ASTType::ContactStmt(contact_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 519:
    ///
    /// `DescriptionStmt: 'description'^ /* Clipped */ Ystring Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn description_stmt(
        &mut self,
        _description: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let description_stmt_built = DescriptionStmt {
            ystring: Box::new(ystring),
        };
        // Calling user action here
        self.user_grammar
            .description_stmt(&description_stmt_built)?;
        self.push(ASTType::DescriptionStmt(description_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 520:
    ///
    /// `ReferenceStmt: 'reference'^ /* Clipped */ Ystring Semicolon^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn reference_stmt(
        &mut self,
        _reference: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let ystring = pop_item!(self, ystring, Ystring, context);
        let reference_stmt_built = ReferenceStmt {
            ystring: Box::new(ystring),
        };
        // Calling user action here
        self.user_grammar.reference_stmt(&reference_stmt_built)?;
        self.push(ASTType::ReferenceStmt(reference_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 521:
    ///
    /// `RevisionStmt: KwRevision^ /* Clipped */ DateArgStr LBrace^ /* Clipped */ RevisionStmtList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_stmt(
        &mut self,
        _kw_revision: &ParseTreeType<'t>,
        _date_arg_str: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _revision_stmt_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let revision_stmt_list =
            pop_and_reverse_item!(self, revision_stmt_list, RevisionStmtList, context);
        self.pop(context);
        let date_arg_str = pop_item!(self, date_arg_str, DateArgStr, context);
        self.pop(context);
        let revision_stmt_built = RevisionStmt {
            date_arg_str: Box::new(date_arg_str),
            revision_stmt_list,
        };
        // Calling user action here
        self.user_grammar.revision_stmt(&revision_stmt_built)?;
        self.push(ASTType::RevisionStmt(revision_stmt_built), context);
        Ok(())
    }

    /// Semantic action for production 522:
    ///
    /// `RevisionStmtList /* Vec<T>::Push */: RevisionStmtListGroup RevisionStmtList;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_stmt_list_0(
        &mut self,
        _revision_stmt_list_group: &ParseTreeType<'t>,
        _revision_stmt_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut revision_stmt_list = pop_item!(self, revision_stmt_list, RevisionStmtList, context);
        let revision_stmt_list_group = pop_item!(
            self,
            revision_stmt_list_group,
            RevisionStmtListGroup,
            context
        );
        let revision_stmt_list_0_built = RevisionStmtList {
            revision_stmt_list_group: Box::new(revision_stmt_list_group),
        };
        // Add an element to the vector
        revision_stmt_list.push(revision_stmt_list_0_built);
        self.push(ASTType::RevisionStmtList(revision_stmt_list), context);
        Ok(())
    }

    /// Semantic action for production 523:
    ///
    /// `RevisionStmtListGroup: DescriptionStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_stmt_list_group_0(&mut self, _description_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let description_stmt = pop_item!(self, description_stmt, DescriptionStmt, context);
        let revision_stmt_list_group_0_built = RevisionStmtListGroupDescriptionStmt {
            description_stmt: Box::new(description_stmt),
        };
        let revision_stmt_list_group_0_built =
            RevisionStmtListGroup::DescriptionStmt(revision_stmt_list_group_0_built);
        self.push(
            ASTType::RevisionStmtListGroup(revision_stmt_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 524:
    ///
    /// `RevisionStmtListGroup: ReferenceStmt;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_stmt_list_group_1(&mut self, _reference_stmt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let reference_stmt = pop_item!(self, reference_stmt, ReferenceStmt, context);
        let revision_stmt_list_group_1_built = RevisionStmtListGroupReferenceStmt {
            reference_stmt: Box::new(reference_stmt),
        };
        let revision_stmt_list_group_1_built =
            RevisionStmtListGroup::ReferenceStmt(revision_stmt_list_group_1_built);
        self.push(
            ASTType::RevisionStmtListGroup(revision_stmt_list_group_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 525:
    ///
    /// `RevisionStmtList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn revision_stmt_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let revision_stmt_list_1_built = Vec::new();
        self.push(
            ASTType::RevisionStmtList(revision_stmt_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 526:
    ///
    /// `DateArgStr: DateArg;`
    ///
    #[parol_runtime::function_name::named]
    fn date_arg_str_0(&mut self, _date_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let date_arg = pop_item!(self, date_arg, DateArg, context);
        let date_arg_str_0_built = DateArgStrDateArg {
            date_arg: Box::new(date_arg),
        };
        let date_arg_str_0_built = DateArgStr::DateArg(date_arg_str_0_built);
        // Calling user action here
        self.user_grammar.date_arg_str(&date_arg_str_0_built)?;
        self.push(ASTType::DateArgStr(date_arg_str_0_built), context);
        Ok(())
    }

    /// Semantic action for production 527:
    ///
    /// `DateArgStr: <Revision>'"'^ /* Clipped */ DateArg <Revision>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn date_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _date_arg: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let date_arg = pop_item!(self, date_arg, DateArg, context);
        let date_arg_str_1_built = DateArgStrDoubleQuotationDateArgDoubleQuotation {
            date_arg: Box::new(date_arg),
        };
        let date_arg_str_1_built =
            DateArgStr::DoubleQuotationDateArgDoubleQuotation(date_arg_str_1_built);
        // Calling user action here
        self.user_grammar.date_arg_str(&date_arg_str_1_built)?;
        self.push(ASTType::DateArgStr(date_arg_str_1_built), context);
        Ok(())
    }

    /// Semantic action for production 528:
    ///
    /// `DateArg: <Revision>/\d{4}-\d{2}-\d{2}/;`
    ///
    #[parol_runtime::function_name::named]
    fn date_arg(&mut self, date_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let date_arg = date_arg.token()?.clone();
        let date_arg_built = DateArg { date_arg };
        // Calling user action here
        self.user_grammar.date_arg(&date_arg_built)?;
        self.push(ASTType::DateArg(date_arg_built), context);
        Ok(())
    }

    /// Semantic action for production 529:
    ///
    /// `Ystring: BasicString YstringOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn ystring_0(
        &mut self,
        _basic_string: &ParseTreeType<'t>,
        _ystring_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ystring_opt = pop_item!(self, ystring_opt, YstringOpt, context);
        let basic_string = pop_item!(self, basic_string, BasicString, context);
        let ystring_0_built = YstringBasicStringYstringOpt {
            basic_string: Box::new(basic_string),
            ystring_opt,
        };
        let ystring_0_built = Ystring::BasicStringYstringOpt(ystring_0_built);
        // Calling user action here
        self.user_grammar.ystring(&ystring_0_built)?;
        self.push(ASTType::Ystring(ystring_0_built), context);
        Ok(())
    }

    /// Semantic action for production 530:
    ///
    /// `Ystring: Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn ystring_1(&mut self, _identifier: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let ystring_1_built = YstringIdentifier {
            identifier: Box::new(identifier),
        };
        let ystring_1_built = Ystring::Identifier(ystring_1_built);
        // Calling user action here
        self.user_grammar.ystring(&ystring_1_built)?;
        self.push(ASTType::Ystring(ystring_1_built), context);
        Ok(())
    }

    /// Semantic action for production 531:
    ///
    /// `YstringOpt /* Option<T>::Some */: '+' Ystring;`
    ///
    #[parol_runtime::function_name::named]
    fn ystring_opt_0(
        &mut self,
        plus: &ParseTreeType<'t>,
        _ystring: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let plus = plus.token()?.clone();
        let ystring = pop_item!(self, ystring, Ystring, context);
        let ystring_opt_0_built = YstringOpt {
            plus,
            ystring: Box::new(ystring),
        };
        self.push(ASTType::YstringOpt(Some(ystring_opt_0_built)), context);
        Ok(())
    }

    /// Semantic action for production 532:
    ///
    /// `YstringOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn ystring_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::YstringOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 533:
    ///
    /// `BasicString: DQString;`
    ///
    #[parol_runtime::function_name::named]
    fn basic_string_0(&mut self, _d_q_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_string = pop_item!(self, d_q_string, DQString, context);
        let basic_string_0_built = BasicStringDQString {
            d_q_string: Box::new(d_q_string),
        };
        let basic_string_0_built = BasicString::DQString(basic_string_0_built);
        // Calling user action here
        self.user_grammar.basic_string(&basic_string_0_built)?;
        self.push(ASTType::BasicString(basic_string_0_built), context);
        Ok(())
    }

    /// Semantic action for production 534:
    ///
    /// `BasicString: SQString;`
    ///
    #[parol_runtime::function_name::named]
    fn basic_string_1(&mut self, _s_q_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_string = pop_item!(self, s_q_string, SQString, context);
        let basic_string_1_built = BasicStringSQString {
            s_q_string: Box::new(s_q_string),
        };
        let basic_string_1_built = BasicString::SQString(basic_string_1_built);
        // Calling user action here
        self.user_grammar.basic_string(&basic_string_1_built)?;
        self.push(ASTType::BasicString(basic_string_1_built), context);
        Ok(())
    }

    /// Semantic action for production 535:
    ///
    /// `DoubleQuotation: <INITIAL, DQString, Esc>'"';`
    ///
    #[parol_runtime::function_name::named]
    fn double_quotation(&mut self, double_quotation: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = double_quotation.token()?.clone();
        let double_quotation_built = DoubleQuotation { double_quotation };
        // Calling user action here
        self.user_grammar
            .double_quotation(&double_quotation_built)?;
        self.push(ASTType::DoubleQuotation(double_quotation_built), context);
        Ok(())
    }

    /// Semantic action for production 536:
    ///
    /// `DQString: DoubleQuotation^ /* Clipped */ DQStringList /* Vec */ DoubleQuotation^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_string(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _d_q_string_list: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let d_q_string_list = pop_and_reverse_item!(self, d_q_string_list, DQStringList, context);
        self.pop(context);
        let d_q_string_built = DQString { d_q_string_list };
        // Calling user action here
        self.user_grammar.d_q_string(&d_q_string_built)?;
        self.push(ASTType::DQString(d_q_string_built), context);
        Ok(())
    }

    /// Semantic action for production 537:
    ///
    /// `DQStringList /* Vec<T>::Push */: DQChar DQStringList;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_string_list_0(
        &mut self,
        _d_q_char: &ParseTreeType<'t>,
        _d_q_string_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut d_q_string_list = pop_item!(self, d_q_string_list, DQStringList, context);
        let d_q_char = pop_item!(self, d_q_char, DQChar, context);
        let d_q_string_list_0_built = DQStringList {
            d_q_char: Box::new(d_q_char),
        };
        // Add an element to the vector
        d_q_string_list.push(d_q_string_list_0_built);
        self.push(ASTType::DQStringList(d_q_string_list), context);
        Ok(())
    }

    /// Semantic action for production 538:
    ///
    /// `DQStringList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_string_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_string_list_1_built = Vec::new();
        self.push(ASTType::DQStringList(d_q_string_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 539:
    ///
    /// `DQChar: DQUnescaped;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_char_0(&mut self, _d_q_unescaped: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_unescaped = pop_item!(self, d_q_unescaped, DQUnescaped, context);
        let d_q_char_0_built = DQCharDQUnescaped {
            d_q_unescaped: Box::new(d_q_unescaped),
        };
        let d_q_char_0_built = DQChar::DQUnescaped(d_q_char_0_built);
        // Calling user action here
        self.user_grammar.d_q_char(&d_q_char_0_built)?;
        self.push(ASTType::DQChar(d_q_char_0_built), context);
        Ok(())
    }

    /// Semantic action for production 540:
    ///
    /// `DQChar: DQEscaped;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_char_1(&mut self, _d_q_escaped: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_escaped = pop_item!(self, d_q_escaped, DQEscaped, context);
        let d_q_char_1_built = DQCharDQEscaped {
            d_q_escaped: Box::new(d_q_escaped),
        };
        let d_q_char_1_built = DQChar::DQEscaped(d_q_char_1_built);
        // Calling user action here
        self.user_grammar.d_q_char(&d_q_char_1_built)?;
        self.push(ASTType::DQChar(d_q_char_1_built), context);
        Ok(())
    }

    /// Semantic action for production 541:
    ///
    /// `DQUnescaped: DQNoEscape;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_unescaped_0(&mut self, _d_q_no_escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_no_escape = pop_item!(self, d_q_no_escape, DQNoEscape, context);
        let d_q_unescaped_0_built = DQUnescapedDQNoEscape {
            d_q_no_escape: Box::new(d_q_no_escape),
        };
        let d_q_unescaped_0_built = DQUnescaped::DQNoEscape(d_q_unescaped_0_built);
        // Calling user action here
        self.user_grammar.d_q_unescaped(&d_q_unescaped_0_built)?;
        self.push(ASTType::DQUnescaped(d_q_unescaped_0_built), context);
        Ok(())
    }

    /// Semantic action for production 542:
    ///
    /// `DQUnescaped: NonAscii;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_unescaped_1(&mut self, _non_ascii: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let non_ascii = pop_item!(self, non_ascii, NonAscii, context);
        let d_q_unescaped_1_built = DQUnescapedNonAscii {
            non_ascii: Box::new(non_ascii),
        };
        let d_q_unescaped_1_built = DQUnescaped::NonAscii(d_q_unescaped_1_built);
        // Calling user action here
        self.user_grammar.d_q_unescaped(&d_q_unescaped_1_built)?;
        self.push(ASTType::DQUnescaped(d_q_unescaped_1_built), context);
        Ok(())
    }

    /// Semantic action for production 543:
    ///
    /// `DQEscaped: Escape DQEscapeSeqChar;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_escaped(
        &mut self,
        _escape: &ParseTreeType<'t>,
        _d_q_escape_seq_char: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_escape_seq_char = pop_item!(self, d_q_escape_seq_char, DQEscapeSeqChar, context);
        let escape = pop_item!(self, escape, Escape, context);
        let d_q_escaped_built = DQEscaped {
            escape: Box::new(escape),
            d_q_escape_seq_char: Box::new(d_q_escape_seq_char),
        };
        // Calling user action here
        self.user_grammar.d_q_escaped(&d_q_escaped_built)?;
        self.push(ASTType::DQEscaped(d_q_escaped_built), context);
        Ok(())
    }

    /// Semantic action for production 544:
    ///
    /// `DQEscapeSeqChar: Escape;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_escape_seq_char_0(&mut self, _escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let escape = pop_item!(self, escape, Escape, context);
        let d_q_escape_seq_char_0_built = DQEscapeSeqCharEscape {
            escape: Box::new(escape),
        };
        let d_q_escape_seq_char_0_built = DQEscapeSeqChar::Escape(d_q_escape_seq_char_0_built);
        // Calling user action here
        self.user_grammar
            .d_q_escape_seq_char(&d_q_escape_seq_char_0_built)?;
        self.push(
            ASTType::DQEscapeSeqChar(d_q_escape_seq_char_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 545:
    ///
    /// `DQEscapeSeqChar: DoubleQuotation;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_escape_seq_char_1(&mut self, _double_quotation: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_quotation = pop_item!(self, double_quotation, DoubleQuotation, context);
        let d_q_escape_seq_char_1_built = DQEscapeSeqCharDoubleQuotation {
            double_quotation: Box::new(double_quotation),
        };
        let d_q_escape_seq_char_1_built =
            DQEscapeSeqChar::DoubleQuotation(d_q_escape_seq_char_1_built);
        // Calling user action here
        self.user_grammar
            .d_q_escape_seq_char(&d_q_escape_seq_char_1_built)?;
        self.push(
            ASTType::DQEscapeSeqChar(d_q_escape_seq_char_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 546:
    ///
    /// `DQEscapeSeqChar: EscN;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_escape_seq_char_2(&mut self, _esc_n: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let esc_n = pop_item!(self, esc_n, EscN, context);
        let d_q_escape_seq_char_2_built = DQEscapeSeqCharEscN {
            esc_n: Box::new(esc_n),
        };
        let d_q_escape_seq_char_2_built = DQEscapeSeqChar::EscN(d_q_escape_seq_char_2_built);
        // Calling user action here
        self.user_grammar
            .d_q_escape_seq_char(&d_q_escape_seq_char_2_built)?;
        self.push(
            ASTType::DQEscapeSeqChar(d_q_escape_seq_char_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 547:
    ///
    /// `DQEscapeSeqChar: EscT;`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_escape_seq_char_3(&mut self, _esc_t: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let esc_t = pop_item!(self, esc_t, EscT, context);
        let d_q_escape_seq_char_3_built = DQEscapeSeqCharEscT {
            esc_t: Box::new(esc_t),
        };
        let d_q_escape_seq_char_3_built = DQEscapeSeqChar::EscT(d_q_escape_seq_char_3_built);
        // Calling user action here
        self.user_grammar
            .d_q_escape_seq_char(&d_q_escape_seq_char_3_built)?;
        self.push(
            ASTType::DQEscapeSeqChar(d_q_escape_seq_char_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 548:
    ///
    /// `Escape: <DQString, SQString, Esc>"\u{5C}";`
    ///
    #[parol_runtime::function_name::named]
    fn escape(&mut self, escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let escape = escape.token()?.clone();
        let escape_built = Escape { escape };
        // Calling user action here
        self.user_grammar.escape(&escape_built)?;
        self.push(ASTType::Escape(escape_built), context);
        Ok(())
    }

    /// Semantic action for production 549:
    ///
    /// `NonAscii: <DQString, SQString>"[\n\r\u{80}-\u{D7FF}\u{E000}-\u{10FFFF}]";`
    ///
    #[parol_runtime::function_name::named]
    fn non_ascii(&mut self, non_ascii: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let non_ascii = non_ascii.token()?.clone();
        let non_ascii_built = NonAscii { non_ascii };
        // Calling user action here
        self.user_grammar.non_ascii(&non_ascii_built)?;
        self.push(ASTType::NonAscii(non_ascii_built), context);
        Ok(())
    }

    /// Semantic action for production 550:
    ///
    /// `DQNoEscape: <DQString>"[ \n\r\t\u{21}\u{23}-\u{5B}\u{5D}-\u{7E}]+";`
    ///
    #[parol_runtime::function_name::named]
    fn d_q_no_escape(&mut self, d_q_no_escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let d_q_no_escape = d_q_no_escape.token()?.clone();
        let d_q_no_escape_built = DQNoEscape { d_q_no_escape };
        // Calling user action here
        self.user_grammar.d_q_no_escape(&d_q_no_escape_built)?;
        self.push(ASTType::DQNoEscape(d_q_no_escape_built), context);
        Ok(())
    }

    /// Semantic action for production 551:
    ///
    /// `SQString: SingleQuotation SQStringList /* Vec */ SingleQuotation;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_string(
        &mut self,
        _single_quotation: &ParseTreeType<'t>,
        _s_q_string_list: &ParseTreeType<'t>,
        _single_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let single_quotation0 = pop_item!(self, single_quotation0, SingleQuotation, context);
        let s_q_string_list = pop_and_reverse_item!(self, s_q_string_list, SQStringList, context);
        let single_quotation = pop_item!(self, single_quotation, SingleQuotation, context);
        let s_q_string_built = SQString {
            single_quotation: Box::new(single_quotation),
            s_q_string_list,
            single_quotation0: Box::new(single_quotation0),
        };
        // Calling user action here
        self.user_grammar.s_q_string(&s_q_string_built)?;
        self.push(ASTType::SQString(s_q_string_built), context);
        Ok(())
    }

    /// Semantic action for production 552:
    ///
    /// `SQStringList /* Vec<T>::Push */: SQChar SQStringList;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_string_list_0(
        &mut self,
        _s_q_char: &ParseTreeType<'t>,
        _s_q_string_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut s_q_string_list = pop_item!(self, s_q_string_list, SQStringList, context);
        let s_q_char = pop_item!(self, s_q_char, SQChar, context);
        let s_q_string_list_0_built = SQStringList {
            s_q_char: Box::new(s_q_char),
        };
        // Add an element to the vector
        s_q_string_list.push(s_q_string_list_0_built);
        self.push(ASTType::SQStringList(s_q_string_list), context);
        Ok(())
    }

    /// Semantic action for production 553:
    ///
    /// `SQStringList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_string_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_string_list_1_built = Vec::new();
        self.push(ASTType::SQStringList(s_q_string_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 554:
    ///
    /// `SQChar: SQUnescaped;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_char_0(&mut self, _s_q_unescaped: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_unescaped = pop_item!(self, s_q_unescaped, SQUnescaped, context);
        let s_q_char_0_built = SQCharSQUnescaped {
            s_q_unescaped: Box::new(s_q_unescaped),
        };
        let s_q_char_0_built = SQChar::SQUnescaped(s_q_char_0_built);
        // Calling user action here
        self.user_grammar.s_q_char(&s_q_char_0_built)?;
        self.push(ASTType::SQChar(s_q_char_0_built), context);
        Ok(())
    }

    /// Semantic action for production 555:
    ///
    /// `SQChar: SQEscaped;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_char_1(&mut self, _s_q_escaped: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_escaped = pop_item!(self, s_q_escaped, SQEscaped, context);
        let s_q_char_1_built = SQCharSQEscaped {
            s_q_escaped: Box::new(s_q_escaped),
        };
        let s_q_char_1_built = SQChar::SQEscaped(s_q_char_1_built);
        // Calling user action here
        self.user_grammar.s_q_char(&s_q_char_1_built)?;
        self.push(ASTType::SQChar(s_q_char_1_built), context);
        Ok(())
    }

    /// Semantic action for production 556:
    ///
    /// `SQEscaped: Escape SQEscapeSeqChar;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_escaped(
        &mut self,
        _escape: &ParseTreeType<'t>,
        _s_q_escape_seq_char: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_escape_seq_char = pop_item!(self, s_q_escape_seq_char, SQEscapeSeqChar, context);
        let escape = pop_item!(self, escape, Escape, context);
        let s_q_escaped_built = SQEscaped {
            escape: Box::new(escape),
            s_q_escape_seq_char: Box::new(s_q_escape_seq_char),
        };
        // Calling user action here
        self.user_grammar.s_q_escaped(&s_q_escaped_built)?;
        self.push(ASTType::SQEscaped(s_q_escaped_built), context);
        Ok(())
    }

    /// Semantic action for production 557:
    ///
    /// `SQEscapeSeqChar: <Esc>".";`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_escape_seq_char(&mut self, s_q_escape_seq_char: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_escape_seq_char = s_q_escape_seq_char.token()?.clone();
        let s_q_escape_seq_char_built = SQEscapeSeqChar {
            s_q_escape_seq_char,
        };
        // Calling user action here
        self.user_grammar
            .s_q_escape_seq_char(&s_q_escape_seq_char_built)?;
        self.push(ASTType::SQEscapeSeqChar(s_q_escape_seq_char_built), context);
        Ok(())
    }

    /// Semantic action for production 558:
    ///
    /// `SQUnescaped: SQNoEscape;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_unescaped_0(&mut self, _s_q_no_escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_no_escape = pop_item!(self, s_q_no_escape, SQNoEscape, context);
        let s_q_unescaped_0_built = SQUnescapedSQNoEscape {
            s_q_no_escape: Box::new(s_q_no_escape),
        };
        let s_q_unescaped_0_built = SQUnescaped::SQNoEscape(s_q_unescaped_0_built);
        // Calling user action here
        self.user_grammar.s_q_unescaped(&s_q_unescaped_0_built)?;
        self.push(ASTType::SQUnescaped(s_q_unescaped_0_built), context);
        Ok(())
    }

    /// Semantic action for production 559:
    ///
    /// `SQUnescaped: NonAscii;`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_unescaped_1(&mut self, _non_ascii: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let non_ascii = pop_item!(self, non_ascii, NonAscii, context);
        let s_q_unescaped_1_built = SQUnescapedNonAscii {
            non_ascii: Box::new(non_ascii),
        };
        let s_q_unescaped_1_built = SQUnescaped::NonAscii(s_q_unescaped_1_built);
        // Calling user action here
        self.user_grammar.s_q_unescaped(&s_q_unescaped_1_built)?;
        self.push(ASTType::SQUnescaped(s_q_unescaped_1_built), context);
        Ok(())
    }

    /// Semantic action for production 560:
    ///
    /// `SQNoEscape: <SQString>"[ \t\u{21}-\u{26}\u{28}-\u{5B}\u{5D}-\u{7E}]+";`
    ///
    #[parol_runtime::function_name::named]
    fn s_q_no_escape(&mut self, s_q_no_escape: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_q_no_escape = s_q_no_escape.token()?.clone();
        let s_q_no_escape_built = SQNoEscape { s_q_no_escape };
        // Calling user action here
        self.user_grammar.s_q_no_escape(&s_q_no_escape_built)?;
        self.push(ASTType::SQNoEscape(s_q_no_escape_built), context);
        Ok(())
    }

    /// Semantic action for production 561:
    ///
    /// `SingleQuotation: <INITIAL, SQString>"\u{27}";`
    ///
    #[parol_runtime::function_name::named]
    fn single_quotation(&mut self, single_quotation: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let single_quotation = single_quotation.token()?.clone();
        let single_quotation_built = SingleQuotation { single_quotation };
        // Calling user action here
        self.user_grammar
            .single_quotation(&single_quotation_built)?;
        self.push(ASTType::SingleQuotation(single_quotation_built), context);
        Ok(())
    }

    /// Semantic action for production 562:
    ///
    /// `IdentifierArgStr: Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_arg_str_0(&mut self, _identifier: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_arg_str_0_built = IdentifierArgStrIdentifier {
            identifier: Box::new(identifier),
        };
        let identifier_arg_str_0_built = IdentifierArgStr::Identifier(identifier_arg_str_0_built);
        // Calling user action here
        self.user_grammar
            .identifier_arg_str(&identifier_arg_str_0_built)?;
        self.push(
            ASTType::IdentifierArgStr(identifier_arg_str_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 563:
    ///
    /// `IdentifierArgStr: <Keyword>'"'^ /* Clipped */ Identifier <Keyword>'"'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_arg_str_1(
        &mut self,
        _double_quotation: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
        _double_quotation0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_arg_str_1_built = IdentifierArgStrDoubleQuotationIdentifierDoubleQuotation {
            identifier: Box::new(identifier),
        };
        let identifier_arg_str_1_built =
            IdentifierArgStr::DoubleQuotationIdentifierDoubleQuotation(identifier_arg_str_1_built);
        // Calling user action here
        self.user_grammar
            .identifier_arg_str(&identifier_arg_str_1_built)?;
        self.push(
            ASTType::IdentifierArgStr(identifier_arg_str_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 564:
    ///
    /// `Identifier: <INITIAL, Keyword, IfFeature>/[a-zA-Z_][a-zA-Z0-9_\-\/\.:]*/;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier(&mut self, identifier: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = identifier.token()?.clone();
        let identifier_built = Identifier { identifier };
        // Calling user action here
        self.user_grammar.identifier(&identifier_built)?;
        self.push(ASTType::Identifier(identifier_built), context);
        Ok(())
    }

    /// Semantic action for production 565:
    ///
    /// `AsciiNoSemicolon: <Default>/[ \t\u{21}\u{23}-\u{3a}\u{3c}-\u{5b}\u{5d}-\u{7e}]+/;`
    ///
    #[parol_runtime::function_name::named]
    fn ascii_no_semicolon(&mut self, ascii_no_semicolon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ascii_no_semicolon = ascii_no_semicolon.token()?.clone();
        let ascii_no_semicolon_built = AsciiNoSemicolon { ascii_no_semicolon };
        // Calling user action here
        self.user_grammar
            .ascii_no_semicolon(&ascii_no_semicolon_built)?;
        self.push(ASTType::AsciiNoSemicolon(ascii_no_semicolon_built), context);
        Ok(())
    }

    /// Semantic action for production 566:
    ///
    /// `AsciiNoBrace: <Enum>/[\t\u{21}\u{23}-\u{3a}\u{3c}-\u{5b}\u{5d}-\u{7a}\u{7c}\u{7e}]+/;`
    ///
    #[parol_runtime::function_name::named]
    fn ascii_no_brace(&mut self, ascii_no_brace: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ascii_no_brace = ascii_no_brace.token()?.clone();
        let ascii_no_brace_built = AsciiNoBrace { ascii_no_brace };
        // Calling user action here
        self.user_grammar.ascii_no_brace(&ascii_no_brace_built)?;
        self.push(ASTType::AsciiNoBrace(ascii_no_brace_built), context);
        Ok(())
    }

    /// Semantic action for production 567:
    ///
    /// `YangVersionArg: <YVersion>"1.1|1";`
    ///
    #[parol_runtime::function_name::named]
    fn yang_version_arg(&mut self, yang_version_arg: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let yang_version_arg = yang_version_arg.token()?.clone();
        let yang_version_arg_built = YangVersionArg { yang_version_arg };
        // Calling user action here
        self.user_grammar
            .yang_version_arg(&yang_version_arg_built)?;
        self.push(ASTType::YangVersionArg(yang_version_arg_built), context);
        Ok(())
    }
}

impl<'t> UserActionsTrait<'t> for YangGrammarAuto<'t, '_> {
    ///
    /// This function is implemented automatically for the user's item YangGrammar.
    ///
    fn call_semantic_action_for_production_number(
        &mut self,
        prod_num: usize,
        children: &[ParseTreeType<'t>],
    ) -> Result<()> {
        match prod_num {
            0 => self.l_brace(&children[0]),
            1 => self.esc_n(&children[0]),
            2 => self.esc_t(&children[0]),
            3 => self.kw_module(&children[0]),
            4 => self.kw_submodule(&children[0]),
            5 => self.kw_rpc(&children[0]),
            6 => self.kw_extension(&children[0]),
            7 => self.kw_argument(&children[0]),
            8 => self.kw_feature(&children[0]),
            9 => self.kw_typedef(&children[0]),
            10 => self.kw_grouping(&children[0]),
            11 => self.kw_identity(&children[0]),
            12 => self.kw_anyxml(&children[0]),
            13 => self.kw_anydata(&children[0]),
            14 => self.kw_case(&children[0]),
            15 => self.kw_container(&children[0]),
            16 => self.kw_action(&children[0]),
            17 => self.kw_notification(&children[0]),
            18 => self.kw_leaf_list(&children[0]),
            19 => self.kw_leaf(&children[0]),
            20 => self.kw_list(&children[0]),
            21 => self.kw_bit(&children[0]),
            22 => self.kw_import(&children[0]),
            23 => self.kw_include(&children[0]),
            24 => self.kw_prefix(&children[0]),
            25 => self.kw_belongs_to(&children[0]),
            26 => self.kw_base(&children[0]),
            27 => self.kw_choice(&children[0]),
            28 => self.kw_uses(&children[0]),
            29 => self.kw_type(&children[0]),
            30 => self.kw_refine(&children[0]),
            31 => self.kw_key(&children[0]),
            32 => self.kw_deviation(&children[0]),
            33 => self.kw_yang_version(&children[0]),
            34 => self.kw_status(&children[0]),
            35 => self.kw_if_feature(&children[0]),
            36 => self.kw_mandatory(&children[0]),
            37 => self.kw_config(&children[0]),
            38 => self.kw_require_instance(&children[0]),
            39 => self.kw_ordered_by(&children[0]),
            40 => self.kw_default(&children[0]),
            41 => self.kw_fraction_digits(&children[0]),
            42 => self.kw_length(&children[0]),
            43 => self.kw_range(&children[0]),
            44 => self.kw_value(&children[0]),
            45 => self.kw_position(&children[0]),
            46 => self.kw_enum(&children[0]),
            47 => self.kw_revision(&children[0]),
            48 => self.kw_revision_date(&children[0]),
            49 => self.kw_namespace(&children[0]),
            50 => self.yang_0(&children[0]),
            51 => self.yang_1(&children[0]),
            52 => self.module_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
                &children[5],
                &children[6],
                &children[7],
                &children[8],
            ),
            53 => self.module_stmt_list3_0(&children[0], &children[1]),
            54 => self.module_stmt_list3_1(),
            55 => self.module_stmt_list2_0(&children[0], &children[1]),
            56 => self.module_stmt_list2_1(),
            57 => self.module_stmt_list1_0(&children[0], &children[1]),
            58 => self.module_stmt_list1_1(),
            59 => self.module_stmt_list0_0(&children[0], &children[1]),
            60 => self.module_stmt_list0_1(),
            61 => self.module_stmt_list_0(&children[0], &children[1]),
            62 => self.module_stmt_list_1(),
            63 => self.submodule_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
                &children[5],
                &children[6],
                &children[7],
                &children[8],
            ),
            64 => self.submodule_stmt_list3_0(&children[0], &children[1]),
            65 => self.submodule_stmt_list3_1(),
            66 => self.submodule_stmt_list2_0(&children[0], &children[1]),
            67 => self.submodule_stmt_list2_1(),
            68 => self.submodule_stmt_list1_0(&children[0], &children[1]),
            69 => self.submodule_stmt_list1_1(),
            70 => self.submodule_stmt_list0_0(&children[0], &children[1]),
            71 => self.submodule_stmt_list0_1(),
            72 => self.submodule_stmt_list_0(&children[0], &children[1]),
            73 => self.submodule_stmt_list_1(),
            74 => self.module_header_stmts_0(&children[0]),
            75 => self.module_header_stmts_1(&children[0]),
            76 => self.module_header_stmts_2(&children[0]),
            77 => self.submodule_header_stmts_0(&children[0]),
            78 => self.submodule_header_stmts_1(&children[0]),
            79 => self.meta_stmts_0(&children[0]),
            80 => self.meta_stmts_1(&children[0]),
            81 => self.meta_stmts_2(&children[0]),
            82 => self.meta_stmts_3(&children[0]),
            83 => self.linkage_stmts_0(&children[0]),
            84 => self.linkage_stmts_1(&children[0]),
            85 => self.body_stmts_0(&children[0]),
            86 => self.body_stmts_1(&children[0]),
            87 => self.body_stmts_2(&children[0]),
            88 => self.body_stmts_3(&children[0]),
            89 => self.body_stmts_4(&children[0]),
            90 => self.body_stmts_5(&children[0]),
            91 => self.body_stmts_6(&children[0]),
            92 => self.body_stmts_7(&children[0]),
            93 => self.body_stmts_8(&children[0]),
            94 => self.body_stmts_9(&children[0]),
            95 => self.body_stmts_10(&children[0]),
            96 => self.data_def_stmt_0(&children[0]),
            97 => self.data_def_stmt_1(&children[0]),
            98 => self.data_def_stmt_2(&children[0]),
            99 => self.data_def_stmt_3(&children[0]),
            100 => self.data_def_stmt_4(&children[0]),
            101 => self.data_def_stmt_5(&children[0]),
            102 => self.data_def_stmt_6(&children[0]),
            103 => self.data_def_stmt_7(&children[0]),
            104 => self.yang_version_stmt(&children[0], &children[1], &children[2]),
            105 => self.yang_version_arg_str_0(&children[0]),
            106 => self.yang_version_arg_str_1(&children[0], &children[1], &children[2]),
            107 => self.deviation_stmt(&children[0], &children[1], &children[2]),
            108 => self.rpc_stmt(&children[0], &children[1], &children[2]),
            109 => self.rpc_stmt_suffix_0(&children[0]),
            110 => self.rpc_stmt_suffix_1(&children[0], &children[1], &children[2]),
            111 => self.rpc_stmt_list_0(&children[0], &children[1]),
            112 => self.rpc_stmt_list_group_0(&children[0]),
            113 => self.rpc_stmt_list_group_1(&children[0]),
            114 => self.rpc_stmt_list_group_2(&children[0]),
            115 => self.rpc_stmt_list_group_3(&children[0]),
            116 => self.rpc_stmt_list_group_4(&children[0]),
            117 => self.rpc_stmt_list_group_5(&children[0]),
            118 => self.rpc_stmt_list_group_6(&children[0]),
            119 => self.rpc_stmt_list_group_7(&children[0]),
            120 => self.rpc_stmt_list_1(),
            121 => self.extension_stmt(&children[0], &children[1], &children[2]),
            122 => self.extension_stmt_suffix_0(&children[0]),
            123 => self.extension_stmt_suffix_1(&children[0], &children[1], &children[2]),
            124 => self.extension_stmt_list_0(&children[0], &children[1]),
            125 => self.extension_stmt_list_group_0(&children[0]),
            126 => self.extension_stmt_list_group_1(&children[0]),
            127 => self.extension_stmt_list_group_2(&children[0]),
            128 => self.extension_stmt_list_group_3(&children[0]),
            129 => self.extension_stmt_list_1(),
            130 => self.argument_stmt(&children[0], &children[1], &children[2]),
            131 => self.feature_stmt(&children[0], &children[1], &children[2]),
            132 => self.feature_stmt_suffix_0(&children[0]),
            133 => self.feature_stmt_suffix_1(&children[0], &children[1], &children[2]),
            134 => self.feature_stmt_list_0(&children[0], &children[1]),
            135 => self.feature_stmt_list_group_0(&children[0]),
            136 => self.feature_stmt_list_group_1(&children[0]),
            137 => self.feature_stmt_list_group_2(&children[0]),
            138 => self.feature_stmt_list_group_3(&children[0]),
            139 => self.feature_stmt_list_1(),
            140 => self.typedef_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            141 => self.typedef_stmt_list_0(&children[0], &children[1]),
            142 => self.typedef_stmt_list_group_0(&children[0]),
            143 => self.typedef_stmt_list_group_1(&children[0]),
            144 => self.typedef_stmt_list_group_2(&children[0]),
            145 => self.typedef_stmt_list_group_3(&children[0]),
            146 => self.typedef_stmt_list_group_4(&children[0]),
            147 => self.typedef_stmt_list_group_5(&children[0]),
            148 => self.typedef_stmt_list_1(),
            149 => self.augment_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            150 => self.augment_stmt_list_0(&children[0], &children[1]),
            151 => self.augment_stmt_list_group_0(&children[0]),
            152 => self.augment_stmt_list_group_1(&children[0]),
            153 => self.augment_stmt_list_group_2(&children[0]),
            154 => self.augment_stmt_list_group_3(&children[0]),
            155 => self.augment_stmt_list_group_4(&children[0]),
            156 => self.augment_stmt_list_group_5(&children[0]),
            157 => self.augment_stmt_list_group_6(&children[0]),
            158 => self.augment_stmt_list_group_7(&children[0]),
            159 => self.augment_stmt_list_group_8(&children[0]),
            160 => self.augment_stmt_list_1(),
            161 => self.augment_arg_str(&children[0]),
            162 => self.when_stmt(&children[0], &children[1], &children[2]),
            163 => self.when_stmt_suffix_0(&children[0]),
            164 => self.when_stmt_suffix_1(&children[0], &children[1], &children[2]),
            165 => self.when_stmt_list_0(&children[0], &children[1]),
            166 => self.when_stmt_list_group_0(&children[0]),
            167 => self.when_stmt_list_group_1(&children[0]),
            168 => self.when_stmt_list_1(),
            169 => self.grouping_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            170 => self.grouping_stmt_list_0(&children[0], &children[1]),
            171 => self.grouping_stmt_list_group_0(&children[0]),
            172 => self.grouping_stmt_list_group_1(&children[0]),
            173 => self.grouping_stmt_list_group_2(&children[0]),
            174 => self.grouping_stmt_list_group_3(&children[0]),
            175 => self.grouping_stmt_list_group_4(&children[0]),
            176 => self.grouping_stmt_list_group_5(&children[0]),
            177 => self.grouping_stmt_list_group_6(&children[0]),
            178 => self.grouping_stmt_list_group_7(&children[0]),
            179 => self.grouping_stmt_list_group_8(&children[0]),
            180 => self.grouping_stmt_list_1(),
            181 => self.identity_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            182 => self.identity_stmt_list_0(&children[0], &children[1]),
            183 => self.identity_stmt_list_group_0(&children[0]),
            184 => self.identity_stmt_list_group_1(&children[0]),
            185 => self.identity_stmt_list_group_2(&children[0]),
            186 => self.identity_stmt_list_group_3(&children[0]),
            187 => self.identity_stmt_list_1(),
            188 => self.base_stmt(&children[0], &children[1], &children[2]),
            189 => self.anyxml_stmt(&children[0], &children[1], &children[2]),
            190 => self.anyxml_stmt_suffix_0(&children[0]),
            191 => self.anyxml_stmt_suffix_1(&children[0], &children[1], &children[2]),
            192 => self.anyxml_stmt_list_0(&children[0], &children[1]),
            193 => self.anyxml_stmt_list_group_0(&children[0]),
            194 => self.anyxml_stmt_list_group_1(&children[0]),
            195 => self.anyxml_stmt_list_group_2(&children[0]),
            196 => self.anyxml_stmt_list_group_3(&children[0]),
            197 => self.anyxml_stmt_list_group_4(&children[0]),
            198 => self.anyxml_stmt_list_group_5(&children[0]),
            199 => self.anyxml_stmt_list_group_6(&children[0]),
            200 => self.anyxml_stmt_list_group_7(&children[0]),
            201 => self.anyxml_stmt_list_1(),
            202 => self.choice_stmt(&children[0], &children[1], &children[2]),
            203 => self.choice_stmt_suffix_0(&children[0]),
            204 => self.choice_stmt_suffix_1(&children[0], &children[1], &children[2]),
            205 => self.choice_stmt_list_0(&children[0], &children[1]),
            206 => self.choice_stmt_list_group_0(&children[0]),
            207 => self.choice_stmt_list_group_1(&children[0]),
            208 => self.choice_stmt_list_group_2(&children[0]),
            209 => self.choice_stmt_list_group_3(&children[0]),
            210 => self.choice_stmt_list_group_4(&children[0]),
            211 => self.choice_stmt_list_group_5(&children[0]),
            212 => self.choice_stmt_list_group_6(&children[0]),
            213 => self.choice_stmt_list_group_7(&children[0]),
            214 => self.choice_stmt_list_group_8(&children[0]),
            215 => self.choice_stmt_list_group_9(&children[0]),
            216 => self.choice_stmt_list_1(),
            217 => self.short_case_stmt_0(&children[0]),
            218 => self.short_case_stmt_1(&children[0]),
            219 => self.short_case_stmt_2(&children[0]),
            220 => self.short_case_stmt_3(&children[0]),
            221 => self.short_case_stmt_4(&children[0]),
            222 => self.short_case_stmt_5(&children[0]),
            223 => self.short_case_stmt_6(&children[0]),
            224 => self.anydata_stmt(&children[0], &children[1], &children[2]),
            225 => self.anydata_stmt_suffix_0(&children[0]),
            226 => self.anydata_stmt_suffix_1(&children[0], &children[1], &children[2]),
            227 => self.anydata_stmt_list_0(&children[0], &children[1]),
            228 => self.anydata_stmt_list_group_0(&children[0]),
            229 => self.anydata_stmt_list_group_1(&children[0]),
            230 => self.anydata_stmt_list_group_2(&children[0]),
            231 => self.anydata_stmt_list_group_3(&children[0]),
            232 => self.anydata_stmt_list_group_4(&children[0]),
            233 => self.anydata_stmt_list_group_5(&children[0]),
            234 => self.anydata_stmt_list_group_6(&children[0]),
            235 => self.anydata_stmt_list_group_7(&children[0]),
            236 => self.anydata_stmt_list_1(),
            237 => self.case_stmt(&children[0], &children[1], &children[2]),
            238 => self.case_stmt_suffix_0(&children[0]),
            239 => self.case_stmt_suffix_1(&children[0], &children[1], &children[2]),
            240 => self.case_stmt_list_0(&children[0], &children[1]),
            241 => self.case_stmt_list_group_0(&children[0]),
            242 => self.case_stmt_list_group_1(&children[0]),
            243 => self.case_stmt_list_group_2(&children[0]),
            244 => self.case_stmt_list_group_3(&children[0]),
            245 => self.case_stmt_list_group_4(&children[0]),
            246 => self.case_stmt_list_1(),
            247 => self.status_stmt(&children[0], &children[1], &children[2]),
            248 => self.status_arg_str_0(&children[0]),
            249 => self.status_arg_str_1(&children[0], &children[1], &children[2]),
            250 => self.status_arg(&children[0]),
            251 => self.container_stmt(&children[0], &children[1], &children[2]),
            252 => self.container_stmt_suffix_0(&children[0]),
            253 => self.container_stmt_suffix_1(&children[0], &children[1], &children[2]),
            254 => self.container_stmt_list_0(&children[0], &children[1]),
            255 => self.container_stmt_list_group_0(&children[0]),
            256 => self.container_stmt_list_group_1(&children[0]),
            257 => self.container_stmt_list_group_2(&children[0]),
            258 => self.container_stmt_list_group_3(&children[0]),
            259 => self.container_stmt_list_group_4(&children[0]),
            260 => self.container_stmt_list_group_5(&children[0]),
            261 => self.container_stmt_list_group_6(&children[0]),
            262 => self.container_stmt_list_group_7(&children[0]),
            263 => self.container_stmt_list_group_8(&children[0]),
            264 => self.container_stmt_list_group_9(&children[0]),
            265 => self.container_stmt_list_group_10(&children[0]),
            266 => self.container_stmt_list_group_11(&children[0]),
            267 => self.container_stmt_list_1(),
            268 => self.action_stmt(&children[0], &children[1], &children[2]),
            269 => self.action_stmt_suffix_0(&children[0]),
            270 => self.action_stmt_suffix_1(&children[0], &children[1], &children[2]),
            271 => self.action_stmt_list_0(&children[0], &children[1]),
            272 => self.action_stmt_list_group_0(&children[0]),
            273 => self.action_stmt_list_group_1(&children[0]),
            274 => self.action_stmt_list_group_2(&children[0]),
            275 => self.action_stmt_list_group_3(&children[0]),
            276 => self.action_stmt_list_group_4(&children[0]),
            277 => self.action_stmt_list_group_5(&children[0]),
            278 => self.action_stmt_list_1(),
            279 => self.input_stmt(&children[0], &children[1], &children[2], &children[3]),
            280 => self.input_stmt_list_0(&children[0], &children[1]),
            281 => self.input_stmt_list_1(),
            282 => self.output_stmt(&children[0], &children[1], &children[2], &children[3]),
            283 => self.output_stmt_list_0(&children[0], &children[1]),
            284 => self.output_stmt_list_1(),
            285 => self.notification_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            286 => self.notification_stmt_list_0(&children[0], &children[1]),
            287 => self.notification_stmt_list_group_0(&children[0]),
            288 => self.notification_stmt_list_group_1(&children[0]),
            289 => self.notification_stmt_list_group_2(&children[0]),
            290 => self.notification_stmt_list_group_3(&children[0]),
            291 => self.notification_stmt_list_group_4(&children[0]),
            292 => self.notification_stmt_list_group_5(&children[0]),
            293 => self.notification_stmt_list_group_6(&children[0]),
            294 => self.notification_stmt_list_group_7(&children[0]),
            295 => self.notification_stmt_list_1(),
            296 => self.if_feature_stmt(&children[0], &children[1], &children[2]),
            297 => self.if_feature_expr_str(&children[0]),
            298 => self.if_feature_expr(&children[0], &children[1]),
            299 => self.if_feature_expr_opt_0(&children[0], &children[1]),
            300 => self.if_feature_expr_opt_1(),
            301 => self.if_feature_term(&children[0], &children[1]),
            302 => self.if_feature_term_opt_0(&children[0], &children[1]),
            303 => self.if_feature_term_opt_1(),
            304 => self.if_feature_factor_0(&children[0], &children[1]),
            305 => self.if_feature_factor_1(&children[0], &children[1], &children[2]),
            306 => self.if_feature_factor_2(&children[0]),
            307 => self.if_feature_factor_3(&children[0], &children[1], &children[2]),
            308 => self.presence_stmt(&children[0], &children[1], &children[2]),
            309 => self.uses_stmt(&children[0], &children[1], &children[2]),
            310 => self.uses_stmt_suffix_0(&children[0]),
            311 => self.uses_stmt_suffix_1(&children[0], &children[1], &children[2]),
            312 => self.uses_stmt_list_0(&children[0], &children[1]),
            313 => self.uses_stmt_list_group_0(&children[0]),
            314 => self.uses_stmt_list_group_1(&children[0]),
            315 => self.uses_stmt_list_group_2(&children[0]),
            316 => self.uses_stmt_list_group_3(&children[0]),
            317 => self.uses_stmt_list_group_4(&children[0]),
            318 => self.uses_stmt_list_group_5(&children[0]),
            319 => self.uses_stmt_list_group_6(&children[0]),
            320 => self.uses_stmt_list_1(),
            321 => self.refine_stmt(&children[0], &children[1], &children[2]),
            322 => self.refine_stmt_suffix_0(&children[0]),
            323 => self.refine_stmt_suffix_1(&children[0], &children[1], &children[2]),
            324 => self.refine_stmt_list_0(&children[0], &children[1]),
            325 => self.refine_stmt_list_group_0(&children[0]),
            326 => self.refine_stmt_list_group_1(&children[0]),
            327 => self.refine_stmt_list_group_2(&children[0]),
            328 => self.refine_stmt_list_group_3(&children[0]),
            329 => self.refine_stmt_list_group_4(&children[0]),
            330 => self.refine_stmt_list_group_5(&children[0]),
            331 => self.refine_stmt_list_group_6(&children[0]),
            332 => self.refine_stmt_list_group_7(&children[0]),
            333 => self.refine_stmt_list_group_8(&children[0]),
            334 => self.refine_stmt_list_group_9(&children[0]),
            335 => self.refine_stmt_list_1(),
            336 => self.refine_arg_str_0(&children[0]),
            337 => self.refine_arg_str_1(&children[0], &children[1], &children[2]),
            338 => self.refine_arg(&children[0]),
            339 => self.descendant_schema_nodeid_0(&children[0]),
            340 => self.descendant_schema_nodeid_1(&children[0]),
            341 => self.unknown_stmt(&children[0], &children[1], &children[2]),
            342 => self.unknown_stmt_suffix_0(&children[0]),
            343 => self.unknown_stmt_suffix_1(&children[0], &children[1], &children[2]),
            344 => self.unknown_stmt_list_0(&children[0], &children[1]),
            345 => self.unknown_stmt_list_group_0(&children[0]),
            346 => self.unknown_stmt_list_group_1(&children[0]),
            347 => self.unknown_stmt_list_1(),
            348 => self.leaf_list_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            349 => self.leaf_list_stmt_list_0(&children[0], &children[1]),
            350 => self.leaf_list_stmt_list_group_0(&children[0]),
            351 => self.leaf_list_stmt_list_group_1(&children[0]),
            352 => self.leaf_list_stmt_list_group_2(&children[0]),
            353 => self.leaf_list_stmt_list_group_3(&children[0]),
            354 => self.leaf_list_stmt_list_group_4(&children[0]),
            355 => self.leaf_list_stmt_list_group_5(&children[0]),
            356 => self.leaf_list_stmt_list_group_6(&children[0]),
            357 => self.leaf_list_stmt_list_group_7(&children[0]),
            358 => self.leaf_list_stmt_list_group_8(&children[0]),
            359 => self.leaf_list_stmt_list_group_9(&children[0]),
            360 => self.leaf_list_stmt_list_group_10(&children[0]),
            361 => self.leaf_list_stmt_list_group_11(&children[0]),
            362 => self.leaf_list_stmt_list_group_12(&children[0]),
            363 => self.leaf_list_stmt_list_group_13(&children[0]),
            364 => self.leaf_list_stmt_list_1(),
            365 => self.leaf_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            366 => self.leaf_stmt_list_0(&children[0], &children[1]),
            367 => self.leaf_stmt_list_group_0(&children[0]),
            368 => self.leaf_stmt_list_group_1(&children[0]),
            369 => self.leaf_stmt_list_group_2(&children[0]),
            370 => self.leaf_stmt_list_group_3(&children[0]),
            371 => self.leaf_stmt_list_group_4(&children[0]),
            372 => self.leaf_stmt_list_group_5(&children[0]),
            373 => self.leaf_stmt_list_group_6(&children[0]),
            374 => self.leaf_stmt_list_group_7(&children[0]),
            375 => self.leaf_stmt_list_group_8(&children[0]),
            376 => self.leaf_stmt_list_group_9(&children[0]),
            377 => self.leaf_stmt_list_group_10(&children[0]),
            378 => self.leaf_stmt_list_group_11(&children[0]),
            379 => self.leaf_stmt_list_1(),
            380 => self.must_stmt(&children[0], &children[1], &children[2]),
            381 => self.must_stmt_suffix_0(&children[0]),
            382 => self.must_stmt_suffix_1(&children[0], &children[1], &children[2]),
            383 => self.must_stmt_list_0(&children[0], &children[1]),
            384 => self.must_stmt_list_group_0(&children[0]),
            385 => self.must_stmt_list_group_1(&children[0]),
            386 => self.must_stmt_list_1(),
            387 => self.error_message(&children[0], &children[1], &children[2]),
            388 => self.units_stmt(&children[0], &children[1], &children[2]),
            389 => self.config_stmt(&children[0], &children[1], &children[2]),
            390 => self.mandatory_stmt(&children[0], &children[1], &children[2]),
            391 => self.mandatory_arg_str_0(&children[0]),
            392 => self.mandatory_arg_str_1(&children[0], &children[1], &children[2]),
            393 => self.mandatory_arg(&children[0]),
            394 => self.list_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            395 => self.list_stmt_list_0(&children[0], &children[1]),
            396 => self.list_stmt_list_group_0(&children[0]),
            397 => self.list_stmt_list_group_1(&children[0]),
            398 => self.list_stmt_list_group_2(&children[0]),
            399 => self.list_stmt_list_group_3(&children[0]),
            400 => self.list_stmt_list_group_4(&children[0]),
            401 => self.list_stmt_list_group_5(&children[0]),
            402 => self.list_stmt_list_group_6(&children[0]),
            403 => self.list_stmt_list_group_7(&children[0]),
            404 => self.list_stmt_list_group_8(&children[0]),
            405 => self.list_stmt_list_group_9(&children[0]),
            406 => self.list_stmt_list_group_10(&children[0]),
            407 => self.list_stmt_list_group_11(&children[0]),
            408 => self.list_stmt_list_group_12(&children[0]),
            409 => self.list_stmt_list_group_13(&children[0]),
            410 => self.list_stmt_list_group_14(&children[0]),
            411 => self.list_stmt_list_1(),
            412 => self.ordered_by_stmt(&children[0], &children[1], &children[2]),
            413 => self.ordered_by_arg_str_0(&children[0]),
            414 => self.ordered_by_arg_str_1(&children[0], &children[1], &children[2]),
            415 => self.ordered_by_arg(&children[0]),
            416 => self.default_stmt(&children[0], &children[1]),
            417 => self.default_stmt_suffix_0(&children[0], &children[1]),
            418 => {
                self.default_stmt_suffix_1(&children[0], &children[1], &children[2], &children[3])
            }
            419 => self.max_elements_stmt(&children[0], &children[1], &children[2]),
            420 => self.min_elements_stmt(&children[0], &children[1], &children[2]),
            421 => self.type_stmt(&children[0], &children[1], &children[2]),
            422 => self.type_stmt_suffix_0(&children[0]),
            423 => self.type_stmt_suffix_1(&children[0], &children[1], &children[2]),
            424 => self.type_stmt_list_0(&children[0], &children[1]),
            425 => self.type_stmt_list_group_0(&children[0]),
            426 => self.type_stmt_list_group_1(&children[0]),
            427 => self.type_stmt_list_group_2(&children[0]),
            428 => self.type_stmt_list_group_3(&children[0]),
            429 => self.type_stmt_list_group_4(&children[0]),
            430 => self.type_stmt_list_group_5(&children[0]),
            431 => self.type_stmt_list_group_6(&children[0]),
            432 => self.type_stmt_list_group_7(&children[0]),
            433 => self.type_stmt_list_1(),
            434 => self.fraction_digits_stmt(&children[0], &children[1], &children[2]),
            435 => self.fraction_digits_arg(&children[0]),
            436 => self.bit_stmt(&children[0], &children[1], &children[2]),
            437 => self.bit_stmt_suffix_0(&children[0]),
            438 => self.bit_stmt_suffix_1(&children[0], &children[1], &children[2]),
            439 => self.bit_stmt_list_0(&children[0], &children[1]),
            440 => self.bit_stmt_list_group_0(&children[0]),
            441 => self.bit_stmt_list_group_1(&children[0]),
            442 => self.bit_stmt_list_group_2(&children[0]),
            443 => self.bit_stmt_list_1(),
            444 => self.position_stmt(&children[0], &children[1], &children[2]),
            445 => self.leafref_specification_0(&children[0]),
            446 => self.leafref_specification_1(&children[0]),
            447 => self.require_instance_stmt(&children[0], &children[1], &children[2]),
            448 => self.require_instance_arg_str_0(&children[0]),
            449 => self.require_instance_arg_str_1(&children[0], &children[1], &children[2]),
            450 => self.path_stmt(&children[0], &children[1], &children[2]),
            451 => self.string_restrictions_0(&children[0]),
            452 => self.string_restrictions_1(&children[0]),
            453 => self.pattern_stmt(&children[0], &children[1], &children[2]),
            454 => self.length_stmt(&children[0], &children[1], &children[2]),
            455 => self.enum_stmt(&children[0], &children[1], &children[2]),
            456 => self.enum_stmt_suffix_0(&children[0]),
            457 => self.enum_stmt_suffix_1(&children[0], &children[1], &children[2]),
            458 => self.enum_stmt_list_0(&children[0], &children[1]),
            459 => self.enum_stmt_list_group_0(&children[0]),
            460 => self.enum_stmt_list_group_1(&children[0]),
            461 => self.enum_stmt_list_group_2(&children[0]),
            462 => self.enum_stmt_list_group_3(&children[0]),
            463 => self.enum_stmt_list_1(),
            464 => self.value_stmt(&children[0], &children[1], &children[2]),
            465 => self.integer_value_str_0(&children[0]),
            466 => self.integer_value_str_1(&children[0], &children[1], &children[2]),
            467 => self.integer_value(&children[0]),
            468 => self.enum_arg_str_0(&children[0]),
            469 => self.enum_arg_str_1(&children[0], &children[1], &children[2]),
            470 => self.range_stmt(&children[0], &children[1], &children[2]),
            471 => self.range_arg_str_0(&children[0]),
            472 => self.range_arg_str_1(&children[0], &children[1], &children[2]),
            473 => self.range_arg(&children[0], &children[1]),
            474 => self.range_arg_opt_0(&children[0], &children[1]),
            475 => self.range_arg_opt_1(),
            476 => self.range_part(&children[0], &children[1]),
            477 => self.range_part_opt_0(&children[0], &children[1]),
            478 => self.range_part_opt_1(),
            479 => self.range_boundary_0(&children[0]),
            480 => self.range_boundary_1(&children[0]),
            481 => self.range_boundary_2(&children[0]),
            482 => self.identifier_ref_arg_str_0(&children[0]),
            483 => self.identifier_ref_arg_str_1(&children[0], &children[1], &children[2]),
            484 => self.identifier_ref(&children[0], &children[1]),
            485 => self.identifier_ref_opt_0(&children[0], &children[1]),
            486 => self.identifier_ref_opt_1(),
            487 => self.key_stmt(&children[0], &children[1], &children[2]),
            488 => self.key_arg_str_0(&children[0]),
            489 => self.key_arg_str_1(&children[0], &children[1], &children[2]),
            490 => self.semicolon(&children[0]),
            491 => self.key_arg(&children[0], &children[1]),
            492 => self.key_arg_opt_0(&children[0]),
            493 => self.key_arg_opt_1(),
            494 => self.absolute_schema_nodeid(&children[0], &children[1]),
            495 => self.import_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            496 => self.import_stmt_list_0(&children[0], &children[1]),
            497 => self.import_stmt_list_group_0(&children[0]),
            498 => self.import_stmt_list_group_1(&children[0]),
            499 => self.import_stmt_list_group_2(&children[0]),
            500 => self.import_stmt_list_group_3(&children[0]),
            501 => self.import_stmt_list_1(),
            502 => self.include_stmt(&children[0], &children[1], &children[2]),
            503 => self.include_stmt_suffix_0(&children[0]),
            504 => self.include_stmt_suffix_1(&children[0], &children[1], &children[2]),
            505 => self.include_stmt_list_0(&children[0], &children[1]),
            506 => self.include_stmt_list_group_0(&children[0]),
            507 => self.include_stmt_list_group_1(&children[0]),
            508 => self.include_stmt_list_group_2(&children[0]),
            509 => self.include_stmt_list_1(),
            510 => self.revision_date_stmt(&children[0], &children[1], &children[2]),
            511 => self.namespace_stmt(&children[0], &children[1], &children[2]),
            512 => self.uri_str_0(&children[0]),
            513 => self.uri_str_1(&children[0], &children[1], &children[2]),
            514 => self.uri_arg(&children[0]),
            515 => self.prefix_stmt(&children[0], &children[1], &children[2]),
            516 => self.belongs_to_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            517 => self.organization_stmt(&children[0], &children[1], &children[2]),
            518 => self.contact_stmt(&children[0], &children[1], &children[2]),
            519 => self.description_stmt(&children[0], &children[1], &children[2]),
            520 => self.reference_stmt(&children[0], &children[1], &children[2]),
            521 => self.revision_stmt(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            522 => self.revision_stmt_list_0(&children[0], &children[1]),
            523 => self.revision_stmt_list_group_0(&children[0]),
            524 => self.revision_stmt_list_group_1(&children[0]),
            525 => self.revision_stmt_list_1(),
            526 => self.date_arg_str_0(&children[0]),
            527 => self.date_arg_str_1(&children[0], &children[1], &children[2]),
            528 => self.date_arg(&children[0]),
            529 => self.ystring_0(&children[0], &children[1]),
            530 => self.ystring_1(&children[0]),
            531 => self.ystring_opt_0(&children[0], &children[1]),
            532 => self.ystring_opt_1(),
            533 => self.basic_string_0(&children[0]),
            534 => self.basic_string_1(&children[0]),
            535 => self.double_quotation(&children[0]),
            536 => self.d_q_string(&children[0], &children[1], &children[2]),
            537 => self.d_q_string_list_0(&children[0], &children[1]),
            538 => self.d_q_string_list_1(),
            539 => self.d_q_char_0(&children[0]),
            540 => self.d_q_char_1(&children[0]),
            541 => self.d_q_unescaped_0(&children[0]),
            542 => self.d_q_unescaped_1(&children[0]),
            543 => self.d_q_escaped(&children[0], &children[1]),
            544 => self.d_q_escape_seq_char_0(&children[0]),
            545 => self.d_q_escape_seq_char_1(&children[0]),
            546 => self.d_q_escape_seq_char_2(&children[0]),
            547 => self.d_q_escape_seq_char_3(&children[0]),
            548 => self.escape(&children[0]),
            549 => self.non_ascii(&children[0]),
            550 => self.d_q_no_escape(&children[0]),
            551 => self.s_q_string(&children[0], &children[1], &children[2]),
            552 => self.s_q_string_list_0(&children[0], &children[1]),
            553 => self.s_q_string_list_1(),
            554 => self.s_q_char_0(&children[0]),
            555 => self.s_q_char_1(&children[0]),
            556 => self.s_q_escaped(&children[0], &children[1]),
            557 => self.s_q_escape_seq_char(&children[0]),
            558 => self.s_q_unescaped_0(&children[0]),
            559 => self.s_q_unescaped_1(&children[0]),
            560 => self.s_q_no_escape(&children[0]),
            561 => self.single_quotation(&children[0]),
            562 => self.identifier_arg_str_0(&children[0]),
            563 => self.identifier_arg_str_1(&children[0], &children[1], &children[2]),
            564 => self.identifier(&children[0]),
            565 => self.ascii_no_semicolon(&children[0]),
            566 => self.ascii_no_brace(&children[0]),
            567 => self.yang_version_arg(&children[0]),
            _ => Err(ParserError::InternalError(format!(
                "Unhandled production number: {prod_num}"
            ))
            .into()),
        }
    }

    fn on_comment(&mut self, token: Token<'t>) {
        self.user_grammar.on_comment(token)
    }
}