#[derive(Clone, Debug, PartialEq, RefNode)]
pub enum RefNode<'a> {
    Locate(&'a Locate),
    ArrayIdentifier(&'a ArrayIdentifier),
    BlockIdentifier(&'a BlockIdentifier),
    BinIdentifier(&'a BinIdentifier),
    CIdentifier(&'a CIdentifier),
    CellIdentifier(&'a CellIdentifier),
    CheckerIdentifier(&'a CheckerIdentifier),
    ClassIdentifier(&'a ClassIdentifier),
    ClassVariableIdentifier(&'a ClassVariableIdentifier),
    ClockingIdentifier(&'a ClockingIdentifier),
    ConfigIdentifier(&'a ConfigIdentifier),
    ConstIdentifier(&'a ConstIdentifier),
    ConstraintIdentifier(&'a ConstraintIdentifier),
    CovergroupIdentifier(&'a CovergroupIdentifier),
    CovergroupVariableIdentifier(&'a CovergroupVariableIdentifier),
    CoverPointIdentifier(&'a CoverPointIdentifier),
    CrossIdentifier(&'a CrossIdentifier),
    DynamicArrayVariableIdentifier(&'a DynamicArrayVariableIdentifier),
    EnumIdentifier(&'a EnumIdentifier),
    EscapedIdentifier(&'a EscapedIdentifier),
    FormalIdentifier(&'a FormalIdentifier),
    FormalPortIdentifier(&'a FormalPortIdentifier),
    FunctionIdentifier(&'a FunctionIdentifier),
    GenerateBlockIdentifier(&'a GenerateBlockIdentifier),
    GenvarIdentifier(&'a GenvarIdentifier),
    HierarchicalArrayIdentifier(&'a HierarchicalArrayIdentifier),
    HierarchicalBlockIdentifier(&'a HierarchicalBlockIdentifier),
    HierarchicalEventIdentifier(&'a HierarchicalEventIdentifier),
    HierarchicalIdentifier(&'a HierarchicalIdentifier),
    Root(&'a Root),
    HierarchicalNetIdentifier(&'a HierarchicalNetIdentifier),
    HierarchicalParameterIdentifier(&'a HierarchicalParameterIdentifier),
    HierarchicalPropertyIdentifier(&'a HierarchicalPropertyIdentifier),
    HierarchicalSequenceIdentifier(&'a HierarchicalSequenceIdentifier),
    HierarchicalTaskIdentifier(&'a HierarchicalTaskIdentifier),
    HierarchicalTfIdentifier(&'a HierarchicalTfIdentifier),
    HierarchicalVariableIdentifier(&'a HierarchicalVariableIdentifier),
    Identifier(&'a Identifier),
    IndexVariableIdentifier(&'a IndexVariableIdentifier),
    InterfaceIdentifier(&'a InterfaceIdentifier),
    InterfaceInstanceIdentifier(&'a InterfaceInstanceIdentifier),
    InoutPortIdentifier(&'a InoutPortIdentifier),
    InputPortIdentifier(&'a InputPortIdentifier),
    InstanceIdentifier(&'a InstanceIdentifier),
    LibraryIdentifier(&'a LibraryIdentifier),
    MemberIdentifier(&'a MemberIdentifier),
    MethodIdentifier(&'a MethodIdentifier),
    ModportIdentifier(&'a ModportIdentifier),
    ModuleIdentifier(&'a ModuleIdentifier),
    NetIdentifier(&'a NetIdentifier),
    NetTypeIdentifier(&'a NetTypeIdentifier),
    OutputPortIdentifier(&'a OutputPortIdentifier),
    PackageIdentifier(&'a PackageIdentifier),
    PackageScope(&'a PackageScope),
    PackageScopePackage(&'a PackageScopePackage),
    Unit(&'a Unit),
    ParameterIdentifier(&'a ParameterIdentifier),
    PortIdentifier(&'a PortIdentifier),
    ProductionIdentifier(&'a ProductionIdentifier),
    ProgramIdentifier(&'a ProgramIdentifier),
    PropertyIdentifier(&'a PropertyIdentifier),
    PsClassIdentifier(&'a PsClassIdentifier),
    PsCovergroupIdentifier(&'a PsCovergroupIdentifier),
    PsCheckerIdentifier(&'a PsCheckerIdentifier),
    PsIdentifier(&'a PsIdentifier),
    PsOrHierarchicalArrayIdentifier(&'a PsOrHierarchicalArrayIdentifier),
    PsOrHierarchicalNetIdentifier(&'a PsOrHierarchicalNetIdentifier),
    PsOrHierarchicalNetIdentifierPackageScope(&'a PsOrHierarchicalNetIdentifierPackageScope),
    PsOrHierarchicalNetIdentifierHierarchical(&'a PsOrHierarchicalNetIdentifierHierarchical),
    PsOrHierarchicalPropertyIdentifier(&'a PsOrHierarchicalPropertyIdentifier),
    PsOrHierarchicalPropertyIdentifierPackageScope(&'a PsOrHierarchicalPropertyIdentifierPackageScope),
    PsOrHierarchicalPropertyIdentifierHierarchical(&'a PsOrHierarchicalPropertyIdentifierHierarchical),
    PsOrHierarchicalSequenceIdentifier(&'a PsOrHierarchicalSequenceIdentifier),
    PsOrHierarchicalSequenceIdentifierPackageScope(&'a PsOrHierarchicalSequenceIdentifierPackageScope),
    PsOrHierarchicalSequenceIdentifierHierarchical(&'a PsOrHierarchicalSequenceIdentifierHierarchical),
    PsOrHierarchicalTfIdentifier(&'a PsOrHierarchicalTfIdentifier),
    PsOrHierarchicalTfIdentifierPackageScope(&'a PsOrHierarchicalTfIdentifierPackageScope),
    PsOrHierarchicalTfIdentifierHierarchical(&'a PsOrHierarchicalTfIdentifierHierarchical),
    PsParameterIdentifier(&'a PsParameterIdentifier),
    PsParameterIdentifierScope(&'a PsParameterIdentifierScope),
    PsParameterIdentifierGenerate(&'a PsParameterIdentifierGenerate),
    PsTypeIdentifier(&'a PsTypeIdentifier),
    LocalOrPackageScopeOrClassScope(&'a LocalOrPackageScopeOrClassScope),
    Local(&'a Local),
    SequenceIdentifier(&'a SequenceIdentifier),
    SignalIdentifier(&'a SignalIdentifier),
    SimpleIdentifier(&'a SimpleIdentifier),
    SpecparamIdentifier(&'a SpecparamIdentifier),
    SystemTfIdentifier(&'a SystemTfIdentifier),
    TaskIdentifier(&'a TaskIdentifier),
    TfIdentifier(&'a TfIdentifier),
    TerminalIdentifier(&'a TerminalIdentifier),
    TopmoduleIdentifier(&'a TopmoduleIdentifier),
    TypeIdentifier(&'a TypeIdentifier),
    UdpIdentifier(&'a UdpIdentifier),
    VariableIdentifier(&'a VariableIdentifier),
    ImplicitClassHandleOrClassScopeOrPackageScope(&'a ImplicitClassHandleOrClassScopeOrPackageScope),
    ImplicitClassHandleOrPackageScope(&'a ImplicitClassHandleOrPackageScope),
    ImplicitClassHandleOrClassScope(&'a ImplicitClassHandleOrClassScope),
    PackageScopeOrClassScope(&'a PackageScopeOrClassScope),
    CompilerDirective(&'a CompilerDirective),
    ResetallCompilerDirective(&'a ResetallCompilerDirective),
    IncludeCompilerDirective(&'a IncludeCompilerDirective),
    IncludeCompilerDirectiveDoubleQuote(&'a IncludeCompilerDirectiveDoubleQuote),
    IncludeCompilerDirectiveAngleBracket(&'a IncludeCompilerDirectiveAngleBracket),
    IncludeCompilerDirectiveTextMacroUsage(&'a IncludeCompilerDirectiveTextMacroUsage),
    AngleBracketLiteral(&'a AngleBracketLiteral),
    TextMacroDefinition(&'a TextMacroDefinition),
    TextMacroName(&'a TextMacroName),
    ListOfFormalArguments(&'a ListOfFormalArguments),
    FormalArgument(&'a FormalArgument),
    TextMacroIdentifier(&'a TextMacroIdentifier),
    MacroText(&'a MacroText),
    DefaultText(&'a DefaultText),
    TextMacroUsage(&'a TextMacroUsage),
    ListOfActualArguments(&'a ListOfActualArguments),
    ActualArgument(&'a ActualArgument),
    UndefineCompilerDirective(&'a UndefineCompilerDirective),
    UndefineallCompilerDirective(&'a UndefineallCompilerDirective),
    ConditionalCompilerDirective(&'a ConditionalCompilerDirective),
    IfdefDirective(&'a IfdefDirective),
    IfndefDirective(&'a IfndefDirective),
    IfdefGroupOfLines(&'a IfdefGroupOfLines),
    IfndefGroupOfLines(&'a IfndefGroupOfLines),
    ElsifGroupOfLines(&'a ElsifGroupOfLines),
    ElseGroupOfLines(&'a ElseGroupOfLines),
    SourceDescription(&'a SourceDescription),
    SourceDescriptionNotDirective(&'a SourceDescriptionNotDirective),
    TimescaleCompilerDirective(&'a TimescaleCompilerDirective),
    DefaultNettypeCompilerDirective(&'a DefaultNettypeCompilerDirective),
    DefaultNettypeValue(&'a DefaultNettypeValue),
    UnconnectedDriveCompilerDirective(&'a UnconnectedDriveCompilerDirective),
    NounconnectedDriveCompilerDirective(&'a NounconnectedDriveCompilerDirective),
    CelldefineDriveCompilerDirective(&'a CelldefineDriveCompilerDirective),
    EndcelldefineDriveCompilerDirective(&'a EndcelldefineDriveCompilerDirective),
    Pragma(&'a Pragma),
    PragmaName(&'a PragmaName),
    PragmaExpression(&'a PragmaExpression),
    PragmaExpressionAssignment(&'a PragmaExpressionAssignment),
    PragmaValue(&'a PragmaValue),
    PragmaValueParen(&'a PragmaValueParen),
    PragmaKeyword(&'a PragmaKeyword),
    LineCompilerDirective(&'a LineCompilerDirective),
    PositionCompilerDirective(&'a PositionCompilerDirective),
    Level(&'a Level),
    KeywordsDirective(&'a KeywordsDirective),
    VersionSpecifier(&'a VersionSpecifier),
    EndkeywordsDirective(&'a EndkeywordsDirective),
    Comment(&'a Comment),
    AttributeInstance(&'a AttributeInstance),
    AttrSpec(&'a AttrSpec),
    SourceText(&'a SourceText),
    Description(&'a Description),
    DescriptionPackageItem(&'a DescriptionPackageItem),
    DescriptionBindDirective(&'a DescriptionBindDirective),
    ModuleNonansiHeader(&'a ModuleNonansiHeader),
    ModuleAnsiHeader(&'a ModuleAnsiHeader),
    ModuleDeclaration(&'a ModuleDeclaration),
    ModuleDeclarationNonansi(&'a ModuleDeclarationNonansi),
    ModuleDeclarationAnsi(&'a ModuleDeclarationAnsi),
    ModuleDeclarationWildcard(&'a ModuleDeclarationWildcard),
    ModuleDeclarationExternNonansi(&'a ModuleDeclarationExternNonansi),
    ModuleDeclarationExternAnsi(&'a ModuleDeclarationExternAnsi),
    ModuleKeyword(&'a ModuleKeyword),
    InterfaceDeclaration(&'a InterfaceDeclaration),
    InterfaceDeclarationNonansi(&'a InterfaceDeclarationNonansi),
    InterfaceDeclarationAnsi(&'a InterfaceDeclarationAnsi),
    InterfaceDeclarationWildcard(&'a InterfaceDeclarationWildcard),
    InterfaceDeclarationExternNonansi(&'a InterfaceDeclarationExternNonansi),
    InterfaceDeclarationExternAnsi(&'a InterfaceDeclarationExternAnsi),
    InterfaceNonansiHeader(&'a InterfaceNonansiHeader),
    InterfaceAnsiHeader(&'a InterfaceAnsiHeader),
    ProgramDeclaration(&'a ProgramDeclaration),
    ProgramDeclarationNonansi(&'a ProgramDeclarationNonansi),
    ProgramDeclarationAnsi(&'a ProgramDeclarationAnsi),
    ProgramDeclarationWildcard(&'a ProgramDeclarationWildcard),
    ProgramDeclarationExternNonansi(&'a ProgramDeclarationExternNonansi),
    ProgramDeclarationExternAnsi(&'a ProgramDeclarationExternAnsi),
    ProgramNonansiHeader(&'a ProgramNonansiHeader),
    ProgramAnsiHeader(&'a ProgramAnsiHeader),
    CheckerDeclaration(&'a CheckerDeclaration),
    ClassDeclaration(&'a ClassDeclaration),
    Virtual(&'a Virtual),
    InterfaceClassType(&'a InterfaceClassType),
    InterfaceClassDeclaration(&'a InterfaceClassDeclaration),
    InterfaceClassItem(&'a InterfaceClassItem),
    InterfaceClassItemMethod(&'a InterfaceClassItemMethod),
    InterfaceClassMethod(&'a InterfaceClassMethod),
    PackageDeclaration(&'a PackageDeclaration),
    TimeunitsDeclaration(&'a TimeunitsDeclaration),
    TimeunitsDeclarationTimeunit(&'a TimeunitsDeclarationTimeunit),
    TimeunitsDeclarationTimeprecision(&'a TimeunitsDeclarationTimeprecision),
    TimeunitsDeclarationTimeunitTimeprecision(&'a TimeunitsDeclarationTimeunitTimeprecision),
    TimeunitsDeclarationTimeprecisionTimeunit(&'a TimeunitsDeclarationTimeprecisionTimeunit),
    PackageItem(&'a PackageItem),
    PackageOrGenerateItemDeclaration(&'a PackageOrGenerateItemDeclaration),
    AnonymousProgram(&'a AnonymousProgram),
    AnonymousProgramItem(&'a AnonymousProgramItem),
    ElaborationSystemTask(&'a ElaborationSystemTask),
    ElaborationSystemTaskFatal(&'a ElaborationSystemTaskFatal),
    ElaborationSystemTaskError(&'a ElaborationSystemTaskError),
    ElaborationSystemTaskWarning(&'a ElaborationSystemTaskWarning),
    ElaborationSystemTaskInfo(&'a ElaborationSystemTaskInfo),
    FinishNumber(&'a FinishNumber),
    ModuleCommonItem(&'a ModuleCommonItem),
    ModuleItem(&'a ModuleItem),
    ModuleOrGenerateItem(&'a ModuleOrGenerateItem),
    ModuleOrGenerateItemParameter(&'a ModuleOrGenerateItemParameter),
    ModuleOrGenerateItemGate(&'a ModuleOrGenerateItemGate),
    ModuleOrGenerateItemUdp(&'a ModuleOrGenerateItemUdp),
    ModuleOrGenerateItemModule(&'a ModuleOrGenerateItemModule),
    ModuleOrGenerateItemModuleItem(&'a ModuleOrGenerateItemModuleItem),
    ModuleOrGenerateItemDeclaration(&'a ModuleOrGenerateItemDeclaration),
    ModuleOrGenerateItemDeclarationClocking(&'a ModuleOrGenerateItemDeclarationClocking),
    ModuleOrGenerateItemDeclarationDisable(&'a ModuleOrGenerateItemDeclarationDisable),
    NonPortModuleItem(&'a NonPortModuleItem),
    NonPortModuleItemSpecparam(&'a NonPortModuleItemSpecparam),
    ParameterOverride(&'a ParameterOverride),
    BindDirective(&'a BindDirective),
    BindDirectiveScope(&'a BindDirectiveScope),
    BindDirectiveInstance(&'a BindDirectiveInstance),
    BindTargetScope(&'a BindTargetScope),
    BindTargetInstance(&'a BindTargetInstance),
    BindTargetInstanceList(&'a BindTargetInstanceList),
    BindInstantiation(&'a BindInstantiation),
    ParameterPortList(&'a ParameterPortList),
    ParameterPortListAssignment(&'a ParameterPortListAssignment),
    ParameterPortListDeclaration(&'a ParameterPortListDeclaration),
    ParameterPortDeclaration(&'a ParameterPortDeclaration),
    ParameterPortDeclarationParamList(&'a ParameterPortDeclarationParamList),
    ParameterPortDeclarationTypeList(&'a ParameterPortDeclarationTypeList),
    ListOfPorts(&'a ListOfPorts),
    ListOfPortDeclarations(&'a ListOfPortDeclarations),
    PortDeclaration(&'a PortDeclaration),
    PortDeclarationInout(&'a PortDeclarationInout),
    PortDeclarationInput(&'a PortDeclarationInput),
    PortDeclarationOutput(&'a PortDeclarationOutput),
    PortDeclarationRef(&'a PortDeclarationRef),
    PortDeclarationInterface(&'a PortDeclarationInterface),
    Port(&'a Port),
    PortNonNamed(&'a PortNonNamed),
    PortNamed(&'a PortNamed),
    PortExpression(&'a PortExpression),
    PortExpressionBrace(&'a PortExpressionBrace),
    PortReference(&'a PortReference),
    PortDirection(&'a PortDirection),
    NetPortHeader(&'a NetPortHeader),
    VariablePortHeader(&'a VariablePortHeader),
    InterfacePortHeader(&'a InterfacePortHeader),
    InterfacePortHeaderIdentifier(&'a InterfacePortHeaderIdentifier),
    InterfacePortHeaderInterface(&'a InterfacePortHeaderInterface),
    NetPortHeaderOrInterfacePortHeader(&'a NetPortHeaderOrInterfacePortHeader),
    AnsiPortDeclaration(&'a AnsiPortDeclaration),
    AnsiPortDeclarationNet(&'a AnsiPortDeclarationNet),
    AnsiPortDeclarationVariable(&'a AnsiPortDeclarationVariable),
    AnsiPortDeclarationParen(&'a AnsiPortDeclarationParen),
    CheckerPortList(&'a CheckerPortList),
    CheckerPortItem(&'a CheckerPortItem),
    CheckerPortDirection(&'a CheckerPortDirection),
    CheckerOrGenerateItem(&'a CheckerOrGenerateItem),
    CheckerOrGenerateItemDeclaration(&'a CheckerOrGenerateItemDeclaration),
    CheckerOrGenerateItemDeclarationData(&'a CheckerOrGenerateItemDeclarationData),
    Rand(&'a Rand),
    CheckerOrGenerateItemDeclarationClocking(&'a CheckerOrGenerateItemDeclarationClocking),
    CheckerOrGenerateItemDeclarationDisable(&'a CheckerOrGenerateItemDeclarationDisable),
    CheckerGenerateItem(&'a CheckerGenerateItem),
    ConstraintDeclaration(&'a ConstraintDeclaration),
    Static(&'a Static),
    ConstraintBlock(&'a ConstraintBlock),
    ConstraintBlockItem(&'a ConstraintBlockItem),
    ConstraintBlockItemSolve(&'a ConstraintBlockItemSolve),
    SolveBeforeList(&'a SolveBeforeList),
    ConstraintPrimary(&'a ConstraintPrimary),
    ConstraintExpression(&'a ConstraintExpression),
    ConstraintExpressionExpression(&'a ConstraintExpressionExpression),
    Soft(&'a Soft),
    ConstraintExpressionArrow(&'a ConstraintExpressionArrow),
    ConstraintExpressionIf(&'a ConstraintExpressionIf),
    ConstraintExpressionForeach(&'a ConstraintExpressionForeach),
    ConstraintExpressionDisable(&'a ConstraintExpressionDisable),
    UniquenessConstraint(&'a UniquenessConstraint),
    ConstraintSet(&'a ConstraintSet),
    ConstraintSetBrace(&'a ConstraintSetBrace),
    DistList(&'a DistList),
    DistItem(&'a DistItem),
    DistWeight(&'a DistWeight),
    DistWeightEqual(&'a DistWeightEqual),
    DistWeightDivide(&'a DistWeightDivide),
    ConstraintPrototype(&'a ConstraintPrototype),
    ConstraintPrototypeQualifier(&'a ConstraintPrototypeQualifier),
    ExternConstraintDeclaration(&'a ExternConstraintDeclaration),
    IdentifierList(&'a IdentifierList),
    InterfaceOrGenerateItem(&'a InterfaceOrGenerateItem),
    InterfaceOrGenerateItemModule(&'a InterfaceOrGenerateItemModule),
    InterfaceOrGenerateItemExtern(&'a InterfaceOrGenerateItemExtern),
    ExternTfDeclaration(&'a ExternTfDeclaration),
    ExternTfDeclarationMethod(&'a ExternTfDeclarationMethod),
    ExternTfDeclarationTask(&'a ExternTfDeclarationTask),
    InterfaceItem(&'a InterfaceItem),
    NonPortInterfaceItem(&'a NonPortInterfaceItem),
    ProgramItem(&'a ProgramItem),
    NonPortProgramItem(&'a NonPortProgramItem),
    NonPortProgramItemAssign(&'a NonPortProgramItemAssign),
    NonPortProgramItemModule(&'a NonPortProgramItemModule),
    NonPortProgramItemInitial(&'a NonPortProgramItemInitial),
    NonPortProgramItemFinal(&'a NonPortProgramItemFinal),
    NonPortProgramItemAssertion(&'a NonPortProgramItemAssertion),
    ProgramGenerateItem(&'a ProgramGenerateItem),
    LibraryText(&'a LibraryText),
    LibraryDescription(&'a LibraryDescription),
    LibraryDeclaration(&'a LibraryDeclaration),
    IncludeStatement(&'a IncludeStatement),
    FilePathSpec(&'a FilePathSpec),
    FilePathSpecNonLiteral(&'a FilePathSpecNonLiteral),
    ConfigDeclaration(&'a ConfigDeclaration),
    DesignStatement(&'a DesignStatement),
    ConfigRuleStatement(&'a ConfigRuleStatement),
    ConfigRuleStatementDefault(&'a ConfigRuleStatementDefault),
    ConfigRuleStatementInstLib(&'a ConfigRuleStatementInstLib),
    ConfigRuleStatementInstUse(&'a ConfigRuleStatementInstUse),
    ConfigRuleStatementCellLib(&'a ConfigRuleStatementCellLib),
    ConfigRuleStatementCellUse(&'a ConfigRuleStatementCellUse),
    DefaultClause(&'a DefaultClause),
    InstClause(&'a InstClause),
    InstName(&'a InstName),
    CellClause(&'a CellClause),
    LiblistClause(&'a LiblistClause),
    UseClause(&'a UseClause),
    UseClauseCell(&'a UseClauseCell),
    UseClauseNamed(&'a UseClauseNamed),
    UseClauseCellNamed(&'a UseClauseCellNamed),
    Config(&'a Config),
    ClassItem(&'a ClassItem),
    ClassItemProperty(&'a ClassItemProperty),
    ClassItemMethod(&'a ClassItemMethod),
    ClassItemConstraint(&'a ClassItemConstraint),
    ClassItemDeclaration(&'a ClassItemDeclaration),
    ClassItemCovergroup(&'a ClassItemCovergroup),
    ClassProperty(&'a ClassProperty),
    ClassPropertyNonConst(&'a ClassPropertyNonConst),
    ClassPropertyConst(&'a ClassPropertyConst),
    ClassPropertyConstExpression(&'a ClassPropertyConstExpression),
    ClassMethod(&'a ClassMethod),
    ClassMethodTask(&'a ClassMethodTask),
    ClassMethodFunction(&'a ClassMethodFunction),
    ClassMethodPureVirtual(&'a ClassMethodPureVirtual),
    ClassMethodExternMethod(&'a ClassMethodExternMethod),
    ClassMethodConstructor(&'a ClassMethodConstructor),
    ClassMethodExternConstructor(&'a ClassMethodExternConstructor),
    ClassConstructorPrototype(&'a ClassConstructorPrototype),
    ClassConstraint(&'a ClassConstraint),
    ClassItemQualifier(&'a ClassItemQualifier),
    PropertyQualifier(&'a PropertyQualifier),
    RandomQualifier(&'a RandomQualifier),
    MethodQualifier(&'a MethodQualifier),
    MethodPrototype(&'a MethodPrototype),
    ClassConstructorDeclaration(&'a ClassConstructorDeclaration),
    New(&'a New),
    Number(&'a Number),
    IntegralNumber(&'a IntegralNumber),
    DecimalNumber(&'a DecimalNumber),
    DecimalNumberBaseUnsigned(&'a DecimalNumberBaseUnsigned),
    DecimalNumberBaseXNumber(&'a DecimalNumberBaseXNumber),
    DecimalNumberBaseZNumber(&'a DecimalNumberBaseZNumber),
    BinaryNumber(&'a BinaryNumber),
    OctalNumber(&'a OctalNumber),
    HexNumber(&'a HexNumber),
    Sign(&'a Sign),
    Size(&'a Size),
    NonZeroUnsignedNumber(&'a NonZeroUnsignedNumber),
    RealNumber(&'a RealNumber),
    RealNumberFloating(&'a RealNumberFloating),
    FixedPointNumber(&'a FixedPointNumber),
    Exp(&'a Exp),
    UnsignedNumber(&'a UnsignedNumber),
    BinaryValue(&'a BinaryValue),
    OctalValue(&'a OctalValue),
    HexValue(&'a HexValue),
    DecimalBase(&'a DecimalBase),
    BinaryBase(&'a BinaryBase),
    OctalBase(&'a OctalBase),
    HexBase(&'a HexBase),
    XNumber(&'a XNumber),
    ZNumber(&'a ZNumber),
    UnbasedUnsizedLiteral(&'a UnbasedUnsizedLiteral),
    UnaryOperator(&'a UnaryOperator),
    BinaryOperator(&'a BinaryOperator),
    IncOrDecOperator(&'a IncOrDecOperator),
    UnaryModulePathOperator(&'a UnaryModulePathOperator),
    BinaryModulePathOperator(&'a BinaryModulePathOperator),
    ConstantPrimary(&'a ConstantPrimary),
    ConstantPrimaryPsParameter(&'a ConstantPrimaryPsParameter),
    ConstantPrimarySpecparam(&'a ConstantPrimarySpecparam),
    ConstantPrimaryFormalPort(&'a ConstantPrimaryFormalPort),
    ConstantPrimaryEnum(&'a ConstantPrimaryEnum),
    ConstantPrimaryConcatenation(&'a ConstantPrimaryConcatenation),
    ConstantPrimaryMultipleConcatenation(&'a ConstantPrimaryMultipleConcatenation),
    ConstantPrimaryMintypmaxExpression(&'a ConstantPrimaryMintypmaxExpression),
    ModulePathPrimary(&'a ModulePathPrimary),
    ModulePathPrimaryMintypmax(&'a ModulePathPrimaryMintypmax),
    Primary(&'a Primary),
    PrimaryHierarchical(&'a PrimaryHierarchical),
    PrimaryConcatenation(&'a PrimaryConcatenation),
    PrimaryMultipleConcatenation(&'a PrimaryMultipleConcatenation),
    PrimaryMintypmaxExpression(&'a PrimaryMintypmaxExpression),
    ClassQualifierOrPackageScope(&'a ClassQualifierOrPackageScope),
    ClassQualifier(&'a ClassQualifier),
    RangeExpression(&'a RangeExpression),
    PrimaryLiteral(&'a PrimaryLiteral),
    TimeLiteral(&'a TimeLiteral),
    TimeLiteralUnsigned(&'a TimeLiteralUnsigned),
    TimeLiteralFixedPoint(&'a TimeLiteralFixedPoint),
    TimeUnit(&'a TimeUnit),
    ImplicitClassHandle(&'a ImplicitClassHandle),
    BitSelect(&'a BitSelect),
    Select(&'a Select),
    NonrangeSelect(&'a NonrangeSelect),
    ConstantBitSelect(&'a ConstantBitSelect),
    ConstantSelect(&'a ConstantSelect),
    ConstantCast(&'a ConstantCast),
    ConstantLetExpression(&'a ConstantLetExpression),
    Cast(&'a Cast),
    Concatenation(&'a Concatenation),
    ConstantConcatenation(&'a ConstantConcatenation),
    ConstantMultipleConcatenation(&'a ConstantMultipleConcatenation),
    ModulePathConcatenation(&'a ModulePathConcatenation),
    ModulePathMultipleConcatenation(&'a ModulePathMultipleConcatenation),
    MultipleConcatenation(&'a MultipleConcatenation),
    StreamingConcatenation(&'a StreamingConcatenation),
    StreamOperator(&'a StreamOperator),
    SliceSize(&'a SliceSize),
    StreamConcatenation(&'a StreamConcatenation),
    StreamExpression(&'a StreamExpression),
    ArrayRangeExpression(&'a ArrayRangeExpression),
    ArrayRangeExpressionColon(&'a ArrayRangeExpressionColon),
    ArrayRangeExpressionPlusColon(&'a ArrayRangeExpressionPlusColon),
    ArrayRangeExpressionMinusColon(&'a ArrayRangeExpressionMinusColon),
    EmptyUnpackedArrayConcatenation(&'a EmptyUnpackedArrayConcatenation),
    IncOrDecExpression(&'a IncOrDecExpression),
    IncOrDecExpressionPrefix(&'a IncOrDecExpressionPrefix),
    IncOrDecExpressionSuffix(&'a IncOrDecExpressionSuffix),
    ConditionalExpression(&'a ConditionalExpression),
    ConstantExpression(&'a ConstantExpression),
    ConstantExpressionUnary(&'a ConstantExpressionUnary),
    ConstantExpressionBinary(&'a ConstantExpressionBinary),
    ConstantExpressionTernary(&'a ConstantExpressionTernary),
    ConstantMintypmaxExpression(&'a ConstantMintypmaxExpression),
    ConstantMintypmaxExpressionTernary(&'a ConstantMintypmaxExpressionTernary),
    ConstantParamExpression(&'a ConstantParamExpression),
    ParamExpression(&'a ParamExpression),
    ConstantRangeExpression(&'a ConstantRangeExpression),
    ConstantPartSelectRange(&'a ConstantPartSelectRange),
    ConstantRange(&'a ConstantRange),
    ConstantIndexedRange(&'a ConstantIndexedRange),
    Expression(&'a Expression),
    ExpressionUnary(&'a ExpressionUnary),
    ExpressionOperatorAssignment(&'a ExpressionOperatorAssignment),
    ExpressionBinary(&'a ExpressionBinary),
    TaggedUnionExpression(&'a TaggedUnionExpression),
    InsideExpression(&'a InsideExpression),
    ValueRange(&'a ValueRange),
    ValueRangeBinary(&'a ValueRangeBinary),
    MintypmaxExpression(&'a MintypmaxExpression),
    MintypmaxExpressionTernary(&'a MintypmaxExpressionTernary),
    ModulePathConditionalExpression(&'a ModulePathConditionalExpression),
    ModulePathExpression(&'a ModulePathExpression),
    ModulePathExpressionUnary(&'a ModulePathExpressionUnary),
    ModulePathExpressionBinary(&'a ModulePathExpressionBinary),
    ModulePathMintypmaxExpression(&'a ModulePathMintypmaxExpression),
    ModulePathMintypmaxExpressionTernary(&'a ModulePathMintypmaxExpressionTernary),
    PartSelectRange(&'a PartSelectRange),
    IndexedRange(&'a IndexedRange),
    GenvarExpression(&'a GenvarExpression),
    ConstantFunctionCall(&'a ConstantFunctionCall),
    TfCall(&'a TfCall),
    SystemTfCall(&'a SystemTfCall),
    SystemTfCallArgOptional(&'a SystemTfCallArgOptional),
    SystemTfCallArgDataType(&'a SystemTfCallArgDataType),
    SystemTfCallArgExpression(&'a SystemTfCallArgExpression),
    SubroutineCall(&'a SubroutineCall),
    SubroutineCallRandomize(&'a SubroutineCallRandomize),
    FunctionSubroutineCall(&'a FunctionSubroutineCall),
    ListOfArguments(&'a ListOfArguments),
    ListOfArgumentsOrdered(&'a ListOfArgumentsOrdered),
    ListOfArgumentsNamed(&'a ListOfArgumentsNamed),
    MethodCall(&'a MethodCall),
    MethodCallBody(&'a MethodCallBody),
    MethodCallBodyUser(&'a MethodCallBodyUser),
    BuiltInMethodCall(&'a BuiltInMethodCall),
    ArrayManipulationCall(&'a ArrayManipulationCall),
    RandomizeCall(&'a RandomizeCall),
    VariableIdentifierListOrNull(&'a VariableIdentifierListOrNull),
    MethodCallRoot(&'a MethodCallRoot),
    ArrayMethodName(&'a ArrayMethodName),
    StringLiteral(&'a StringLiteral),
    NetLvalue(&'a NetLvalue),
    NetLvalueIdentifier(&'a NetLvalueIdentifier),
    NetLvalueLvalue(&'a NetLvalueLvalue),
    NetLvaluePattern(&'a NetLvaluePattern),
    VariableLvalue(&'a VariableLvalue),
    VariableLvalueIdentifier(&'a VariableLvalueIdentifier),
    VariableLvalueLvalue(&'a VariableLvalueLvalue),
    VariableLvaluePattern(&'a VariableLvaluePattern),
    NonrangeVariableLvalue(&'a NonrangeVariableLvalue),
    PreprocessorText(&'a PreprocessorText),
    CmosSwitchtype(&'a CmosSwitchtype),
    EnableGatetype(&'a EnableGatetype),
    MosSwitchtype(&'a MosSwitchtype),
    NInputGatetype(&'a NInputGatetype),
    NOutputGatetype(&'a NOutputGatetype),
    PassEnSwitchtype(&'a PassEnSwitchtype),
    PassSwitchtype(&'a PassSwitchtype),
    PulldownStrength(&'a PulldownStrength),
    PulldownStrength01(&'a PulldownStrength01),
    PulldownStrength10(&'a PulldownStrength10),
    PulldownStrength0(&'a PulldownStrength0),
    PullupStrength(&'a PullupStrength),
    PullupStrength01(&'a PullupStrength01),
    PullupStrength10(&'a PullupStrength10),
    PullupStrength1(&'a PullupStrength1),
    EnableTerminal(&'a EnableTerminal),
    InoutTerminal(&'a InoutTerminal),
    InputTerminal(&'a InputTerminal),
    NcontrolTerminal(&'a NcontrolTerminal),
    OutputTerminal(&'a OutputTerminal),
    PcontrolTerminal(&'a PcontrolTerminal),
    GateInstantiation(&'a GateInstantiation),
    GateInstantiationCmos(&'a GateInstantiationCmos),
    GateInstantiationEnable(&'a GateInstantiationEnable),
    GateInstantiationMos(&'a GateInstantiationMos),
    GateInstantiationNInput(&'a GateInstantiationNInput),
    GateInstantiationNOutput(&'a GateInstantiationNOutput),
    GateInstantiationPassEn(&'a GateInstantiationPassEn),
    GateInstantiationPass(&'a GateInstantiationPass),
    GateInstantiationPulldown(&'a GateInstantiationPulldown),
    GateInstantiationPullup(&'a GateInstantiationPullup),
    CmosSwitchInstance(&'a CmosSwitchInstance),
    EnableGateInstance(&'a EnableGateInstance),
    MosSwitchInstance(&'a MosSwitchInstance),
    NInputGateInstance(&'a NInputGateInstance),
    NOutputGateInstance(&'a NOutputGateInstance),
    PassSwitchInstance(&'a PassSwitchInstance),
    PassEnableSwitchInstance(&'a PassEnableSwitchInstance),
    PullGateInstance(&'a PullGateInstance),
    ConcurrentAssertionItem(&'a ConcurrentAssertionItem),
    ConcurrentAssertionItemStatement(&'a ConcurrentAssertionItemStatement),
    ConcurrentAssertionStatement(&'a ConcurrentAssertionStatement),
    AssertPropertyStatement(&'a AssertPropertyStatement),
    AssumePropertyStatement(&'a AssumePropertyStatement),
    CoverPropertyStatement(&'a CoverPropertyStatement),
    ExpectPropertyStatement(&'a ExpectPropertyStatement),
    CoverSequenceStatement(&'a CoverSequenceStatement),
    RestrictPropertyStatement(&'a RestrictPropertyStatement),
    PropertyInstance(&'a PropertyInstance),
    PropertyListOfArguments(&'a PropertyListOfArguments),
    PropertyListOfArgumentsOrdered(&'a PropertyListOfArgumentsOrdered),
    PropertyListOfArgumentsNamed(&'a PropertyListOfArgumentsNamed),
    PropertyActualArg(&'a PropertyActualArg),
    AssertionItemDeclaration(&'a AssertionItemDeclaration),
    PropertyDeclaration(&'a PropertyDeclaration),
    PropertyPortList(&'a PropertyPortList),
    PropertyPortItem(&'a PropertyPortItem),
    PropertyLvarPortDirection(&'a PropertyLvarPortDirection),
    PropertyFormalType(&'a PropertyFormalType),
    PropertySpec(&'a PropertySpec),
    PropertyExpr(&'a PropertyExpr),
    PropertyExprStrong(&'a PropertyExprStrong),
    PropertyExprWeak(&'a PropertyExprWeak),
    PropertyExprParen(&'a PropertyExprParen),
    PropertyExprNot(&'a PropertyExprNot),
    PropertyExprBinaryProperty(&'a PropertyExprBinaryProperty),
    PropertyExprBinarySequence(&'a PropertyExprBinarySequence),
    PropertyExprIf(&'a PropertyExprIf),
    PropertyExprCase(&'a PropertyExprCase),
    PropertyExprNexttime(&'a PropertyExprNexttime),
    PropertyExprSNexttime(&'a PropertyExprSNexttime),
    PropertyExprAlways(&'a PropertyExprAlways),
    PropertyExprSAlways(&'a PropertyExprSAlways),
    PropertyExprEventually(&'a PropertyExprEventually),
    PropertyExprSEventually(&'a PropertyExprSEventually),
    PropertyExprAcceptOn(&'a PropertyExprAcceptOn),
    PropertyExprRejectOn(&'a PropertyExprRejectOn),
    PropertyExprSyncAcceptOn(&'a PropertyExprSyncAcceptOn),
    PropertyExprSyncRejectOn(&'a PropertyExprSyncRejectOn),
    PropertyExprClockingEvent(&'a PropertyExprClockingEvent),
    PropertyCaseItem(&'a PropertyCaseItem),
    PropertyCaseItemNondefault(&'a PropertyCaseItemNondefault),
    PropertyCaseItemDefault(&'a PropertyCaseItemDefault),
    SequenceDeclaration(&'a SequenceDeclaration),
    SequencePortList(&'a SequencePortList),
    SequencePortItem(&'a SequencePortItem),
    SequenceLvarPortDirection(&'a SequenceLvarPortDirection),
    SequenceFormalType(&'a SequenceFormalType),
    SequenceExpr(&'a SequenceExpr),
    SequenceExprCycleDelayExpr(&'a SequenceExprCycleDelayExpr),
    SequenceExprExprCycleDelayExpr(&'a SequenceExprExprCycleDelayExpr),
    SequenceExprExpression(&'a SequenceExprExpression),
    SequenceExprInstance(&'a SequenceExprInstance),
    SequenceExprParen(&'a SequenceExprParen),
    SequenceExprBinary(&'a SequenceExprBinary),
    SequenceExprFirstMatch(&'a SequenceExprFirstMatch),
    SequenceExprThroughout(&'a SequenceExprThroughout),
    SequenceExprClockingEvent(&'a SequenceExprClockingEvent),
    CycleDelayRange(&'a CycleDelayRange),
    CycleDelayRangePrimary(&'a CycleDelayRangePrimary),
    CycleDelayRangeExpression(&'a CycleDelayRangeExpression),
    CycleDelayRangeAsterisk(&'a CycleDelayRangeAsterisk),
    CycleDelayRangePlus(&'a CycleDelayRangePlus),
    SequenceMethodCall(&'a SequenceMethodCall),
    SequenceMatchItem(&'a SequenceMatchItem),
    SequenceInstance(&'a SequenceInstance),
    SequenceListOfArguments(&'a SequenceListOfArguments),
    SequenceListOfArgumentsOrdered(&'a SequenceListOfArgumentsOrdered),
    SequenceListOfArgumentsNamed(&'a SequenceListOfArgumentsNamed),
    SequenceActualArg(&'a SequenceActualArg),
    BooleanAbbrev(&'a BooleanAbbrev),
    SequenceAbbrev(&'a SequenceAbbrev),
    ConsecutiveRepetition(&'a ConsecutiveRepetition),
    ConsecutiveRepetitionExpression(&'a ConsecutiveRepetitionExpression),
    ConsecutiveRepetitionAsterisk(&'a ConsecutiveRepetitionAsterisk),
    ConsecutiveRepetitionPlus(&'a ConsecutiveRepetitionPlus),
    NonConsecutiveRepetition(&'a NonConsecutiveRepetition),
    GotoRepetition(&'a GotoRepetition),
    ConstOrRangeExpression(&'a ConstOrRangeExpression),
    CycleDelayConstRangeExpression(&'a CycleDelayConstRangeExpression),
    CycleDelayConstRangeExpressionBinary(&'a CycleDelayConstRangeExpressionBinary),
    CycleDelayConstRangeExpressionDollar(&'a CycleDelayConstRangeExpressionDollar),
    ExpressionOrDist(&'a ExpressionOrDist),
    AssertionVariableDeclaration(&'a AssertionVariableDeclaration),
    TaskDeclaration(&'a TaskDeclaration),
    TaskBodyDeclaration(&'a TaskBodyDeclaration),
    TaskBodyDeclarationWithoutPort(&'a TaskBodyDeclarationWithoutPort),
    TaskBodyDeclarationWithPort(&'a TaskBodyDeclarationWithPort),
    TfItemDeclaration(&'a TfItemDeclaration),
    TfPortList(&'a TfPortList),
    TfPortItem(&'a TfPortItem),
    TfPortDirection(&'a TfPortDirection),
    TfPortDeclaration(&'a TfPortDeclaration),
    TaskPrototype(&'a TaskPrototype),
    DefparamAssignment(&'a DefparamAssignment),
    NetDeclAssignment(&'a NetDeclAssignment),
    ParamAssignment(&'a ParamAssignment),
    SpecparamAssignment(&'a SpecparamAssignment),
    SpecparamAssignmentMintypmax(&'a SpecparamAssignmentMintypmax),
    TypeAssignment(&'a TypeAssignment),
    PulseControlSpecparam(&'a PulseControlSpecparam),
    PulseControlSpecparamWithoutDescriptor(&'a PulseControlSpecparamWithoutDescriptor),
    PulseControlSpecparamWithDescriptor(&'a PulseControlSpecparamWithDescriptor),
    ErrorLimitValue(&'a ErrorLimitValue),
    RejectLimitValue(&'a RejectLimitValue),
    LimitValue(&'a LimitValue),
    VariableDeclAssignment(&'a VariableDeclAssignment),
    VariableDeclAssignmentVariable(&'a VariableDeclAssignmentVariable),
    VariableDeclAssignmentDynamicArray(&'a VariableDeclAssignmentDynamicArray),
    VariableDeclAssignmentClass(&'a VariableDeclAssignmentClass),
    ClassNew(&'a ClassNew),
    ClassNewArgument(&'a ClassNewArgument),
    ClassNewExpression(&'a ClassNewExpression),
    DynamicArrayNew(&'a DynamicArrayNew),
    ListOfDefparamAssignments(&'a ListOfDefparamAssignments),
    ListOfGenvarIdentifiers(&'a ListOfGenvarIdentifiers),
    ListOfInterfaceIdentifiers(&'a ListOfInterfaceIdentifiers),
    ListOfNetDeclAssignments(&'a ListOfNetDeclAssignments),
    ListOfParamAssignments(&'a ListOfParamAssignments),
    ListOfPortIdentifiers(&'a ListOfPortIdentifiers),
    ListOfUdpPortIdentifiers(&'a ListOfUdpPortIdentifiers),
    ListOfSpecparamAssignments(&'a ListOfSpecparamAssignments),
    ListOfTfVariableIdentifiers(&'a ListOfTfVariableIdentifiers),
    ListOfTypeAssignments(&'a ListOfTypeAssignments),
    ListOfVariableDeclAssignments(&'a ListOfVariableDeclAssignments),
    ListOfVariableIdentifiers(&'a ListOfVariableIdentifiers),
    ListOfVariablePortIdentifiers(&'a ListOfVariablePortIdentifiers),
    DataDeclaration(&'a DataDeclaration),
    DataDeclarationVariable(&'a DataDeclarationVariable),
    Const(&'a Const),
    PackageImportDeclaration(&'a PackageImportDeclaration),
    PackageImportItem(&'a PackageImportItem),
    PackageImportItemIdentifier(&'a PackageImportItemIdentifier),
    PackageImportItemAsterisk(&'a PackageImportItemAsterisk),
    PackageExportDeclaration(&'a PackageExportDeclaration),
    PackageExportDeclarationAsterisk(&'a PackageExportDeclarationAsterisk),
    PackageExportDeclarationItem(&'a PackageExportDeclarationItem),
    GenvarDeclaration(&'a GenvarDeclaration),
    NetDeclaration(&'a NetDeclaration),
    NetDeclarationNetType(&'a NetDeclarationNetType),
    Strength(&'a Strength),
    VectorScalar(&'a VectorScalar),
    NetDeclarationNetTypeIdentifier(&'a NetDeclarationNetTypeIdentifier),
    NetDeclarationInterconnect(&'a NetDeclarationInterconnect),
    TypeDeclaration(&'a TypeDeclaration),
    TypeDeclarationDataType(&'a TypeDeclarationDataType),
    TypeDeclarationInterface(&'a TypeDeclarationInterface),
    TypeDeclarationReserved(&'a TypeDeclarationReserved),
    TypeDeclarationKeyword(&'a TypeDeclarationKeyword),
    NetTypeDeclaration(&'a NetTypeDeclaration),
    NetTypeDeclarationDataType(&'a NetTypeDeclarationDataType),
    NetTypeDeclarationNetType(&'a NetTypeDeclarationNetType),
    Lifetime(&'a Lifetime),
    DriveStrength(&'a DriveStrength),
    DriveStrength01(&'a DriveStrength01),
    DriveStrength10(&'a DriveStrength10),
    DriveStrength0z(&'a DriveStrength0z),
    DriveStrength1z(&'a DriveStrength1z),
    DriveStrengthz1(&'a DriveStrengthz1),
    DriveStrengthz0(&'a DriveStrengthz0),
    Strength0(&'a Strength0),
    Strength1(&'a Strength1),
    ChargeStrength(&'a ChargeStrength),
    ChargeStrengthSmall(&'a ChargeStrengthSmall),
    ChargeStrengthMedium(&'a ChargeStrengthMedium),
    ChargeStrengthLarge(&'a ChargeStrengthLarge),
    LetDeclaration(&'a LetDeclaration),
    LetIdentifier(&'a LetIdentifier),
    LetPortList(&'a LetPortList),
    LetPortItem(&'a LetPortItem),
    LetFormalType(&'a LetFormalType),
    LetExpression(&'a LetExpression),
    LetListOfArguments(&'a LetListOfArguments),
    LetListOfArgumentsOrdered(&'a LetListOfArgumentsOrdered),
    LetListOfArgumentsNamed(&'a LetListOfArgumentsNamed),
    LetActualArg(&'a LetActualArg),
    InoutDeclaration(&'a InoutDeclaration),
    InputDeclaration(&'a InputDeclaration),
    InputDeclarationNet(&'a InputDeclarationNet),
    InputDeclarationVariable(&'a InputDeclarationVariable),
    OutputDeclaration(&'a OutputDeclaration),
    OutputDeclarationNet(&'a OutputDeclarationNet),
    OutputDeclarationVariable(&'a OutputDeclarationVariable),
    InterfacePortDeclaration(&'a InterfacePortDeclaration),
    RefDeclaration(&'a RefDeclaration),
    UnpackedDimension(&'a UnpackedDimension),
    UnpackedDimensionRange(&'a UnpackedDimensionRange),
    UnpackedDimensionExpression(&'a UnpackedDimensionExpression),
    PackedDimension(&'a PackedDimension),
    PackedDimensionRange(&'a PackedDimensionRange),
    AssociativeDimension(&'a AssociativeDimension),
    AssociativeDimensionDataType(&'a AssociativeDimensionDataType),
    AssociativeDimensionAsterisk(&'a AssociativeDimensionAsterisk),
    VariableDimension(&'a VariableDimension),
    QueueDimension(&'a QueueDimension),
    UnsizedDimension(&'a UnsizedDimension),
    LocalParameterDeclaration(&'a LocalParameterDeclaration),
    LocalParameterDeclarationParam(&'a LocalParameterDeclarationParam),
    LocalParameterDeclarationType(&'a LocalParameterDeclarationType),
    ParameterDeclaration(&'a ParameterDeclaration),
    ParameterDeclarationParam(&'a ParameterDeclarationParam),
    ParameterDeclarationType(&'a ParameterDeclarationType),
    SpecparamDeclaration(&'a SpecparamDeclaration),
    CovergroupDeclaration(&'a CovergroupDeclaration),
    CoverageSpecOrOption(&'a CoverageSpecOrOption),
    CoverageSpecOrOptionSpec(&'a CoverageSpecOrOptionSpec),
    CoverageSpecOrOptionOption(&'a CoverageSpecOrOptionOption),
    CoverageOption(&'a CoverageOption),
    CoverageOptionOption(&'a CoverageOptionOption),
    CoverageOptionTypeOption(&'a CoverageOptionTypeOption),
    CoverageSpec(&'a CoverageSpec),
    CoverageEvent(&'a CoverageEvent),
    CoverageEventSample(&'a CoverageEventSample),
    CoverageEventAt(&'a CoverageEventAt),
    BlockEventExpression(&'a BlockEventExpression),
    BlockEventExpressionOr(&'a BlockEventExpressionOr),
    BlockEventExpressionBegin(&'a BlockEventExpressionBegin),
    BlockEventExpressionEnd(&'a BlockEventExpressionEnd),
    HierarchicalBtfIdentifier(&'a HierarchicalBtfIdentifier),
    HierarchicalBtfIdentifierMethod(&'a HierarchicalBtfIdentifierMethod),
    HierarchicalIdentifierOrClassScope(&'a HierarchicalIdentifierOrClassScope),
    CoverPoint(&'a CoverPoint),
    BinsOrEmpty(&'a BinsOrEmpty),
    BinsOrEmptyNonEmpty(&'a BinsOrEmptyNonEmpty),
    BinsOrOptions(&'a BinsOrOptions),
    BinsOrOptionsCovergroup(&'a BinsOrOptionsCovergroup),
    Wildcard(&'a Wildcard),
    BinsOrOptionsCoverPoint(&'a BinsOrOptionsCoverPoint),
    BinsOrOptionsSetCovergroup(&'a BinsOrOptionsSetCovergroup),
    BinsOrOptionsTransList(&'a BinsOrOptionsTransList),
    BinsOrOptionsDefault(&'a BinsOrOptionsDefault),
    BinsOrOptionsDefaultSequence(&'a BinsOrOptionsDefaultSequence),
    BinsKeyword(&'a BinsKeyword),
    TransList(&'a TransList),
    TransSet(&'a TransSet),
    TransRangeList(&'a TransRangeList),
    TransRangeListAsterisk(&'a TransRangeListAsterisk),
    TransRangeListArrow(&'a TransRangeListArrow),
    TransRangeListEqual(&'a TransRangeListEqual),
    TransItem(&'a TransItem),
    RepeatRange(&'a RepeatRange),
    RepeatRangeBinary(&'a RepeatRangeBinary),
    CoverCross(&'a CoverCross),
    ListOfCrossItems(&'a ListOfCrossItems),
    CrossItem(&'a CrossItem),
    CrossBody(&'a CrossBody),
    CrossBodyNonEmpty(&'a CrossBodyNonEmpty),
    CrossBodyItem(&'a CrossBodyItem),
    BinsSelectionOrOption(&'a BinsSelectionOrOption),
    BinsSelectionOrOptionCoverage(&'a BinsSelectionOrOptionCoverage),
    BinsSelectionOrOptionBins(&'a BinsSelectionOrOptionBins),
    BinsSelection(&'a BinsSelection),
    SelectExpression(&'a SelectExpression),
    SelectExpressionNot(&'a SelectExpressionNot),
    SelectExpressionAnd(&'a SelectExpressionAnd),
    SelectExpressionOr(&'a SelectExpressionOr),
    SelectExpressionParen(&'a SelectExpressionParen),
    SelectExpressionWith(&'a SelectExpressionWith),
    SelectExpressionCrossSet(&'a SelectExpressionCrossSet),
    SelectCondition(&'a SelectCondition),
    BinsExpression(&'a BinsExpression),
    BinsExpressionCoverPoint(&'a BinsExpressionCoverPoint),
    CovergroupRangeList(&'a CovergroupRangeList),
    CovergroupValueRange(&'a CovergroupValueRange),
    CovergroupValueRangeBinary(&'a CovergroupValueRangeBinary),
    WithCovergroupExpression(&'a WithCovergroupExpression),
    SetCovergroupExpression(&'a SetCovergroupExpression),
    IntegerCovergroupExpression(&'a IntegerCovergroupExpression),
    CrossSetExpression(&'a CrossSetExpression),
    CovergroupExpression(&'a CovergroupExpression),
    BlockItemDeclaration(&'a BlockItemDeclaration),
    BlockItemDeclarationData(&'a BlockItemDeclarationData),
    BlockItemDeclarationLocalParameter(&'a BlockItemDeclarationLocalParameter),
    BlockItemDeclarationParameter(&'a BlockItemDeclarationParameter),
    BlockItemDeclarationLet(&'a BlockItemDeclarationLet),
    Delay3(&'a Delay3),
    Delay3Single(&'a Delay3Single),
    Delay3Mintypmax(&'a Delay3Mintypmax),
    Delay2(&'a Delay2),
    Delay2Single(&'a Delay2Single),
    Delay2Mintypmax(&'a Delay2Mintypmax),
    DelayValue(&'a DelayValue),
    ModportDeclaration(&'a ModportDeclaration),
    ModportItem(&'a ModportItem),
    ModportPortsDeclaration(&'a ModportPortsDeclaration),
    ModportPortsDeclarationSimple(&'a ModportPortsDeclarationSimple),
    ModportPortsDeclarationTf(&'a ModportPortsDeclarationTf),
    ModportPortsDeclarationClocking(&'a ModportPortsDeclarationClocking),
    ModportClockingDeclaration(&'a ModportClockingDeclaration),
    ModportSimplePortsDeclaration(&'a ModportSimplePortsDeclaration),
    ModportSimplePort(&'a ModportSimplePort),
    ModportSimplePortOrdered(&'a ModportSimplePortOrdered),
    ModportSimplePortNamed(&'a ModportSimplePortNamed),
    ModportTfPortsDeclaration(&'a ModportTfPortsDeclaration),
    ModportTfPort(&'a ModportTfPort),
    ImportExport(&'a ImportExport),
    CastingType(&'a CastingType),
    DataType(&'a DataType),
    DataTypeVector(&'a DataTypeVector),
    DataTypeAtom(&'a DataTypeAtom),
    DataTypeStructUnion(&'a DataTypeStructUnion),
    Packed(&'a Packed),
    DataTypeEnum(&'a DataTypeEnum),
    DataTypeVirtual(&'a DataTypeVirtual),
    Interface(&'a Interface),
    DataTypeType(&'a DataTypeType),
    DataTypeOrImplicit(&'a DataTypeOrImplicit),
    ImplicitDataType(&'a ImplicitDataType),
    EnumBaseType(&'a EnumBaseType),
    EnumBaseTypeAtom(&'a EnumBaseTypeAtom),
    EnumBaseTypeVector(&'a EnumBaseTypeVector),
    EnumBaseTypeType(&'a EnumBaseTypeType),
    EnumNameDeclaration(&'a EnumNameDeclaration),
    ClassScope(&'a ClassScope),
    ClassType(&'a ClassType),
    IntegerType(&'a IntegerType),
    IntegerAtomType(&'a IntegerAtomType),
    IntegerVectorType(&'a IntegerVectorType),
    NonIntegerType(&'a NonIntegerType),
    NetType(&'a NetType),
    NetPortType(&'a NetPortType),
    NetPortTypeDataType(&'a NetPortTypeDataType),
    NetPortTypeInterconnect(&'a NetPortTypeInterconnect),
    VariablePortType(&'a VariablePortType),
    VarDataType(&'a VarDataType),
    VarDataTypeVar(&'a VarDataTypeVar),
    Signing(&'a Signing),
    SimpleType(&'a SimpleType),
    StructUnionMember(&'a StructUnionMember),
    DataTypeOrVoid(&'a DataTypeOrVoid),
    StructUnion(&'a StructUnion),
    TypeReference(&'a TypeReference),
    TypeReferenceExpression(&'a TypeReferenceExpression),
    TypeReferenceDataType(&'a TypeReferenceDataType),
    FunctionDataTypeOrImplicit(&'a FunctionDataTypeOrImplicit),
    FunctionDeclaration(&'a FunctionDeclaration),
    FunctionBodyDeclaration(&'a FunctionBodyDeclaration),
    FunctionBodyDeclarationWithoutPort(&'a FunctionBodyDeclarationWithoutPort),
    FunctionBodyDeclarationWithPort(&'a FunctionBodyDeclarationWithPort),
    InterfaceIdentifierOrClassScope(&'a InterfaceIdentifierOrClassScope),
    FunctionPrototype(&'a FunctionPrototype),
    DpiImportExport(&'a DpiImportExport),
    DpiImportExportImportFunction(&'a DpiImportExportImportFunction),
    DpiImportExportImportTask(&'a DpiImportExportImportTask),
    DpiImportExportExportFunction(&'a DpiImportExportExportFunction),
    DpiImportExportExportTask(&'a DpiImportExportExportTask),
    DpiSpecString(&'a DpiSpecString),
    DpiFunctionImportProperty(&'a DpiFunctionImportProperty),
    DpiTaskImportProperty(&'a DpiTaskImportProperty),
    DpiFunctionProto(&'a DpiFunctionProto),
    DpiTaskProto(&'a DpiTaskProto),
    Symbol(&'a Symbol),
    Keyword(&'a Keyword),
    WhiteSpace(&'a WhiteSpace),
    TimingCheckEvent(&'a TimingCheckEvent),
    ControlledTimingCheckEvent(&'a ControlledTimingCheckEvent),
    TimingCheckEventControl(&'a TimingCheckEventControl),
    SpecifyTerminalDescriptor(&'a SpecifyTerminalDescriptor),
    EdgeControlSpecifier(&'a EdgeControlSpecifier),
    EdgeDescriptor(&'a EdgeDescriptor),
    TimingCheckCondition(&'a TimingCheckCondition),
    TimingCheckConditionParen(&'a TimingCheckConditionParen),
    ScalarTimingCheckCondition(&'a ScalarTimingCheckCondition),
    ScalarTimingCheckConditionUnary(&'a ScalarTimingCheckConditionUnary),
    ScalarTimingCheckConditionBinary(&'a ScalarTimingCheckConditionBinary),
    ScalarConstant(&'a ScalarConstant),
    SpecifyBlock(&'a SpecifyBlock),
    SpecifyItem(&'a SpecifyItem),
    PulsestyleDeclaration(&'a PulsestyleDeclaration),
    ShowcancelledDeclaration(&'a ShowcancelledDeclaration),
    SystemTimingCheck(&'a SystemTimingCheck),
    SetupTimingCheck(&'a SetupTimingCheck),
    HoldTimingCheck(&'a HoldTimingCheck),
    SetupholdTimingCheck(&'a SetupholdTimingCheck),
    RecoveryTimingCheck(&'a RecoveryTimingCheck),
    RemovalTimingCheck(&'a RemovalTimingCheck),
    RecremTimingCheck(&'a RecremTimingCheck),
    SkewTimingCheck(&'a SkewTimingCheck),
    TimeskewTimingCheck(&'a TimeskewTimingCheck),
    FullskewTimingCheck(&'a FullskewTimingCheck),
    PeriodTimingCheck(&'a PeriodTimingCheck),
    WidthTimingCheck(&'a WidthTimingCheck),
    NochangeTimingCheck(&'a NochangeTimingCheck),
    PathDelayValue(&'a PathDelayValue),
    PathDelayValueParen(&'a PathDelayValueParen),
    ListOfPathDelayExpressions(&'a ListOfPathDelayExpressions),
    TPathDelayExpression(&'a TPathDelayExpression),
    PathDelayExpression(&'a PathDelayExpression),
    EdgeSensitivePathDeclaration(&'a EdgeSensitivePathDeclaration),
    EdgeSensitivePathDeclarationParallel(&'a EdgeSensitivePathDeclarationParallel),
    EdgeSensitivePathDeclarationFull(&'a EdgeSensitivePathDeclarationFull),
    ParallelEdgeSensitivePathDescription(&'a ParallelEdgeSensitivePathDescription),
    FullEdgeSensitivePathDescription(&'a FullEdgeSensitivePathDescription),
    DataSourceExpression(&'a DataSourceExpression),
    EdgeIdentifier(&'a EdgeIdentifier),
    StateDependentPathDeclaration(&'a StateDependentPathDeclaration),
    StateDependentPathDeclarationIfSimple(&'a StateDependentPathDeclarationIfSimple),
    StateDependentPathDeclarationIfEdgeSensitive(&'a StateDependentPathDeclarationIfEdgeSensitive),
    StateDependentPathDeclarationIfNone(&'a StateDependentPathDeclarationIfNone),
    PolarityOperator(&'a PolarityOperator),
    TimecheckCondition(&'a TimecheckCondition),
    ControlledReferenceEvent(&'a ControlledReferenceEvent),
    DataEvent(&'a DataEvent),
    DelayedData(&'a DelayedData),
    DelayedDataWithMintypmax(&'a DelayedDataWithMintypmax),
    DelayedReference(&'a DelayedReference),
    DelayedReferenceWithMintypmax(&'a DelayedReferenceWithMintypmax),
    EndEdgeOffset(&'a EndEdgeOffset),
    EventBasedFlag(&'a EventBasedFlag),
    Notifier(&'a Notifier),
    ReferenceEvent(&'a ReferenceEvent),
    RemainActiveFlag(&'a RemainActiveFlag),
    TimestampCondition(&'a TimestampCondition),
    StartEdgeOffset(&'a StartEdgeOffset),
    Threshold(&'a Threshold),
    TimingCheckLimit(&'a TimingCheckLimit),
    PathDeclaration(&'a PathDeclaration),
    SimplePathDeclaration(&'a SimplePathDeclaration),
    SimplePathDeclarationParallel(&'a SimplePathDeclarationParallel),
    SimplePathDeclarationFull(&'a SimplePathDeclarationFull),
    ParallelPathDescription(&'a ParallelPathDescription),
    FullPathDescription(&'a FullPathDescription),
    ListOfPathInputs(&'a ListOfPathInputs),
    ListOfPathOutputs(&'a ListOfPathOutputs),
    SpecifyInputTerminalDescriptor(&'a SpecifyInputTerminalDescriptor),
    SpecifyOutputTerminalDescriptor(&'a SpecifyOutputTerminalDescriptor),
    InputIdentifier(&'a InputIdentifier),
    InputIdentifierInterface(&'a InputIdentifierInterface),
    OutputIdentifier(&'a OutputIdentifier),
    OutputIdentifierInterface(&'a OutputIdentifierInterface),
    LoopStatement(&'a LoopStatement),
    LoopStatementForever(&'a LoopStatementForever),
    LoopStatementRepeat(&'a LoopStatementRepeat),
    LoopStatementWhile(&'a LoopStatementWhile),
    LoopStatementFor(&'a LoopStatementFor),
    LoopStatementDoWhile(&'a LoopStatementDoWhile),
    LoopStatementForeach(&'a LoopStatementForeach),
    ForInitialization(&'a ForInitialization),
    ForInitializationDeclaration(&'a ForInitializationDeclaration),
    ForVariableDeclaration(&'a ForVariableDeclaration),
    Var(&'a Var),
    ForStep(&'a ForStep),
    ForStepAssignment(&'a ForStepAssignment),
    LoopVariables(&'a LoopVariables),
    CaseStatement(&'a CaseStatement),
    CaseStatementNormal(&'a CaseStatementNormal),
    CaseStatementMatches(&'a CaseStatementMatches),
    CaseStatementInside(&'a CaseStatementInside),
    CaseKeyword(&'a CaseKeyword),
    CaseExpression(&'a CaseExpression),
    CaseItem(&'a CaseItem),
    CaseItemNondefault(&'a CaseItemNondefault),
    CaseItemDefault(&'a CaseItemDefault),
    CasePatternItem(&'a CasePatternItem),
    CasePatternItemNondefault(&'a CasePatternItemNondefault),
    CaseInsideItem(&'a CaseInsideItem),
    CaseInsideItemNondefault(&'a CaseInsideItemNondefault),
    CaseItemExpression(&'a CaseItemExpression),
    RandcaseStatement(&'a RandcaseStatement),
    RandcaseItem(&'a RandcaseItem),
    OpenRangeList(&'a OpenRangeList),
    OpenValueRange(&'a OpenValueRange),
    ContinuousAssign(&'a ContinuousAssign),
    ContinuousAssignNet(&'a ContinuousAssignNet),
    ContinuousAssignVariable(&'a ContinuousAssignVariable),
    ListOfNetAssignments(&'a ListOfNetAssignments),
    ListOfVariableAssignments(&'a ListOfVariableAssignments),
    NetAlias(&'a NetAlias),
    NetAssignment(&'a NetAssignment),
    ConditionalStatement(&'a ConditionalStatement),
    UniquePriority(&'a UniquePriority),
    CondPredicate(&'a CondPredicate),
    ExpressionOrCondPattern(&'a ExpressionOrCondPattern),
    CondPattern(&'a CondPattern),
    ProceduralTimingControlStatement(&'a ProceduralTimingControlStatement),
    DelayOrEventControl(&'a DelayOrEventControl),
    DelayOrEventControlRepeat(&'a DelayOrEventControlRepeat),
    DelayControl(&'a DelayControl),
    DelayControlDelay(&'a DelayControlDelay),
    DelayControlMintypmax(&'a DelayControlMintypmax),
    EventControl(&'a EventControl),
    EventControlEventIdentifier(&'a EventControlEventIdentifier),
    EventControlEventExpression(&'a EventControlEventExpression),
    EventControlAsterisk(&'a EventControlAsterisk),
    EventControlParenAsterisk(&'a EventControlParenAsterisk),
    EventControlSequenceIdentifier(&'a EventControlSequenceIdentifier),
    EventExpression(&'a EventExpression),
    EventExpressionExpression(&'a EventExpressionExpression),
    EventExpressionSequence(&'a EventExpressionSequence),
    EventExpressionOr(&'a EventExpressionOr),
    EventExpressionComma(&'a EventExpressionComma),
    EventExpressionParen(&'a EventExpressionParen),
    ProceduralTimingControl(&'a ProceduralTimingControl),
    JumpStatement(&'a JumpStatement),
    JumpStatementReturn(&'a JumpStatementReturn),
    JumpStatementBreak(&'a JumpStatementBreak),
    JumpStatementContinue(&'a JumpStatementContinue),
    WaitStatement(&'a WaitStatement),
    WaitStatementWait(&'a WaitStatementWait),
    WaitStatementFork(&'a WaitStatementFork),
    WaitStatementOrder(&'a WaitStatementOrder),
    EventTrigger(&'a EventTrigger),
    EventTriggerNamed(&'a EventTriggerNamed),
    EventTriggerNonblocking(&'a EventTriggerNonblocking),
    DisableStatement(&'a DisableStatement),
    DisableStatementTask(&'a DisableStatementTask),
    DisableStatementBlock(&'a DisableStatementBlock),
    DisableStatementFork(&'a DisableStatementFork),
    RandsequenceStatement(&'a RandsequenceStatement),
    Production(&'a Production),
    RsRule(&'a RsRule),
    RsProductionList(&'a RsProductionList),
    RsProductionListProd(&'a RsProductionListProd),
    RsProductionListJoin(&'a RsProductionListJoin),
    WeightSpecification(&'a WeightSpecification),
    WeightSpecificationExpression(&'a WeightSpecificationExpression),
    RsCodeBlock(&'a RsCodeBlock),
    RsProd(&'a RsProd),
    ProductionItem(&'a ProductionItem),
    RsIfElse(&'a RsIfElse),
    RsRepeat(&'a RsRepeat),
    RsCase(&'a RsCase),
    RsCaseItem(&'a RsCaseItem),
    RsCaseItemNondefault(&'a RsCaseItemNondefault),
    RsCaseItemDefault(&'a RsCaseItemDefault),
    Pattern(&'a Pattern),
    PatternVariable(&'a PatternVariable),
    PatternTagged(&'a PatternTagged),
    PatternList(&'a PatternList),
    PatternIdentifierList(&'a PatternIdentifierList),
    AssignmentPattern(&'a AssignmentPattern),
    AssignmentPatternList(&'a AssignmentPatternList),
    AssignmentPatternStructure(&'a AssignmentPatternStructure),
    AssignmentPatternArray(&'a AssignmentPatternArray),
    AssignmentPatternRepeat(&'a AssignmentPatternRepeat),
    StructurePatternKey(&'a StructurePatternKey),
    ArrayPatternKey(&'a ArrayPatternKey),
    AssignmentPatternKey(&'a AssignmentPatternKey),
    AssignmentPatternExpression(&'a AssignmentPatternExpression),
    AssignmentPatternExpressionType(&'a AssignmentPatternExpressionType),
    ConstantAssignmentPatternExpression(&'a ConstantAssignmentPatternExpression),
    AssignmentPatternNetLvalue(&'a AssignmentPatternNetLvalue),
    AssignmentPatternVariableLvalue(&'a AssignmentPatternVariableLvalue),
    AssertionItem(&'a AssertionItem),
    DeferredImmediateAssetionItem(&'a DeferredImmediateAssetionItem),
    ProceduralAssertionStatement(&'a ProceduralAssertionStatement),
    ImmediateAssetionStatement(&'a ImmediateAssetionStatement),
    SimpleImmediateAssertionStatement(&'a SimpleImmediateAssertionStatement),
    SimpleImmediateAssertStatement(&'a SimpleImmediateAssertStatement),
    SimpleImmediateAssumeStatement(&'a SimpleImmediateAssumeStatement),
    SimpleImmediateCoverStatement(&'a SimpleImmediateCoverStatement),
    DeferredImmediateAssertionStatement(&'a DeferredImmediateAssertionStatement),
    DeferredImmediateAssertStatement(&'a DeferredImmediateAssertStatement),
    DeferredImmediateAssumeStatement(&'a DeferredImmediateAssumeStatement),
    DeferredImmediateCoverStatement(&'a DeferredImmediateCoverStatement),
    AssertTiming(&'a AssertTiming),
    InitialConstruct(&'a InitialConstruct),
    AlwaysConstruct(&'a AlwaysConstruct),
    AlwaysKeyword(&'a AlwaysKeyword),
    FinalConstruct(&'a FinalConstruct),
    BlockingAssignment(&'a BlockingAssignment),
    BlockingAssignmentVariable(&'a BlockingAssignmentVariable),
    BlockingAssignmentNonrangeVariable(&'a BlockingAssignmentNonrangeVariable),
    BlockingAssignmentHierarchicalVariable(&'a BlockingAssignmentHierarchicalVariable),
    OperatorAssignment(&'a OperatorAssignment),
    AssignmentOperator(&'a AssignmentOperator),
    NonblockingAssignment(&'a NonblockingAssignment),
    ProceduralContinuousAssignment(&'a ProceduralContinuousAssignment),
    ProceduralContinuousAssignmentAssign(&'a ProceduralContinuousAssignmentAssign),
    ProceduralContinuousAssignmentDeassign(&'a ProceduralContinuousAssignmentDeassign),
    ProceduralContinuousAssignmentForceVariable(&'a ProceduralContinuousAssignmentForceVariable),
    ProceduralContinuousAssignmentForceNet(&'a ProceduralContinuousAssignmentForceNet),
    ProceduralContinuousAssignmentReleaseVariable(&'a ProceduralContinuousAssignmentReleaseVariable),
    ProceduralContinuousAssignmentReleaseNet(&'a ProceduralContinuousAssignmentReleaseNet),
    VariableAssignment(&'a VariableAssignment),
    SubroutineCallStatement(&'a SubroutineCallStatement),
    SubroutineCallStatementFunction(&'a SubroutineCallStatementFunction),
    ClockingDeclaration(&'a ClockingDeclaration),
    ClockingDeclarationLocal(&'a ClockingDeclarationLocal),
    Default(&'a Default),
    ClockingDeclarationGlobal(&'a ClockingDeclarationGlobal),
    ClockingEvent(&'a ClockingEvent),
    ClockingEventIdentifier(&'a ClockingEventIdentifier),
    ClockingEventExpression(&'a ClockingEventExpression),
    ClockingItem(&'a ClockingItem),
    ClockingItemDefault(&'a ClockingItemDefault),
    ClockingItemDirection(&'a ClockingItemDirection),
    ClockingItemAssertion(&'a ClockingItemAssertion),
    DefaultSkew(&'a DefaultSkew),
    DefaultSkewInput(&'a DefaultSkewInput),
    DefaultSkewOutput(&'a DefaultSkewOutput),
    DefaultSkewInputOutput(&'a DefaultSkewInputOutput),
    ClockingDirection(&'a ClockingDirection),
    ClockingDirectionInput(&'a ClockingDirectionInput),
    ClockingDirectionOutput(&'a ClockingDirectionOutput),
    ClockingDirectionInputOutput(&'a ClockingDirectionInputOutput),
    ListOfClockingDeclAssign(&'a ListOfClockingDeclAssign),
    ClockingDeclAssign(&'a ClockingDeclAssign),
    ClockingSkew(&'a ClockingSkew),
    ClockingSkewEdge(&'a ClockingSkewEdge),
    ClockingDrive(&'a ClockingDrive),
    CycleDelay(&'a CycleDelay),
    CycleDelayIntegral(&'a CycleDelayIntegral),
    CycleDelayIdentifier(&'a CycleDelayIdentifier),
    CycleDelayExpression(&'a CycleDelayExpression),
    Clockvar(&'a Clockvar),
    ClockvarExpression(&'a ClockvarExpression),
    ActionBlock(&'a ActionBlock),
    ActionBlockElse(&'a ActionBlockElse),
    SeqBlock(&'a SeqBlock),
    ParBlock(&'a ParBlock),
    JoinKeyword(&'a JoinKeyword),
    StatementOrNull(&'a StatementOrNull),
    StatementOrNullAttribute(&'a StatementOrNullAttribute),
    Statement(&'a Statement),
    StatementItem(&'a StatementItem),
    FunctionStatement(&'a FunctionStatement),
    FunctionStatementOrNull(&'a FunctionStatementOrNull),
    FunctionStatementOrNullAttribute(&'a FunctionStatementOrNullAttribute),
    VariableIdentifierList(&'a VariableIdentifierList),
    UdpInstantiation(&'a UdpInstantiation),
    UdpInstance(&'a UdpInstance),
    UdpNonansiDeclaration(&'a UdpNonansiDeclaration),
    UdpAnsiDeclaration(&'a UdpAnsiDeclaration),
    UdpDeclaration(&'a UdpDeclaration),
    UdpDeclarationNonansi(&'a UdpDeclarationNonansi),
    UdpDeclarationAnsi(&'a UdpDeclarationAnsi),
    UdpDeclarationExternNonansi(&'a UdpDeclarationExternNonansi),
    UdpDeclarationExternAnsi(&'a UdpDeclarationExternAnsi),
    UdpDeclarationWildcard(&'a UdpDeclarationWildcard),
    UdpBody(&'a UdpBody),
    CombinationalBody(&'a CombinationalBody),
    CombinationalEntry(&'a CombinationalEntry),
    SequentialBody(&'a SequentialBody),
    UdpInitialStatement(&'a UdpInitialStatement),
    InitVal(&'a InitVal),
    SequentialEntry(&'a SequentialEntry),
    SeqInputList(&'a SeqInputList),
    LevelInputList(&'a LevelInputList),
    EdgeInputList(&'a EdgeInputList),
    EdgeIndicator(&'a EdgeIndicator),
    EdgeIndicatorParen(&'a EdgeIndicatorParen),
    CurrentState(&'a CurrentState),
    NextState(&'a NextState),
    OutputSymbol(&'a OutputSymbol),
    LevelSymbol(&'a LevelSymbol),
    EdgeSymbol(&'a EdgeSymbol),
    UdpPortList(&'a UdpPortList),
    UdpDeclarationPortList(&'a UdpDeclarationPortList),
    UdpPortDeclaration(&'a UdpPortDeclaration),
    UdpOutputDeclaration(&'a UdpOutputDeclaration),
    UdpOutputDeclarationNonreg(&'a UdpOutputDeclarationNonreg),
    UdpOutputDeclarationReg(&'a UdpOutputDeclarationReg),
    UdpInputDeclaration(&'a UdpInputDeclaration),
    UdpRegDeclaration(&'a UdpRegDeclaration),
    InterfaceInstantiation(&'a InterfaceInstantiation),
    CheckerInstantiation(&'a CheckerInstantiation),
    ListOfCheckerPortConnections(&'a ListOfCheckerPortConnections),
    ListOfCheckerPortConnectionsOrdered(&'a ListOfCheckerPortConnectionsOrdered),
    ListOfCheckerPortConnectionsNamed(&'a ListOfCheckerPortConnectionsNamed),
    OrderedCheckerPortConnection(&'a OrderedCheckerPortConnection),
    NamedCheckerPortConnection(&'a NamedCheckerPortConnection),
    NamedCheckerPortConnectionIdentifier(&'a NamedCheckerPortConnectionIdentifier),
    NamedCheckerPortConnectionAsterisk(&'a NamedCheckerPortConnectionAsterisk),
    ModuleInstantiation(&'a ModuleInstantiation),
    ParameterValueAssignment(&'a ParameterValueAssignment),
    ListOfParameterAssignments(&'a ListOfParameterAssignments),
    ListOfParameterAssignmentsOrdered(&'a ListOfParameterAssignmentsOrdered),
    ListOfParameterAssignmentsNamed(&'a ListOfParameterAssignmentsNamed),
    OrderedParameterAssignment(&'a OrderedParameterAssignment),
    NamedParameterAssignment(&'a NamedParameterAssignment),
    HierarchicalInstance(&'a HierarchicalInstance),
    NameOfInstance(&'a NameOfInstance),
    ListOfPortConnections(&'a ListOfPortConnections),
    ListOfPortConnectionsOrdered(&'a ListOfPortConnectionsOrdered),
    ListOfPortConnectionsNamed(&'a ListOfPortConnectionsNamed),
    OrderedPortConnection(&'a OrderedPortConnection),
    NamedPortConnection(&'a NamedPortConnection),
    NamedPortConnectionIdentifier(&'a NamedPortConnectionIdentifier),
    NamedPortConnectionAsterisk(&'a NamedPortConnectionAsterisk),
    ProgramInstantiation(&'a ProgramInstantiation),
    GenerateRegion(&'a GenerateRegion),
    LoopGenerateConstruct(&'a LoopGenerateConstruct),
    GenvarInitialization(&'a GenvarInitialization),
    Genvar(&'a Genvar),
    GenvarIteration(&'a GenvarIteration),
    GenvarIterationAssignment(&'a GenvarIterationAssignment),
    GenvarIterationPrefix(&'a GenvarIterationPrefix),
    GenvarIterationSuffix(&'a GenvarIterationSuffix),
    ConditionalGenerateConstruct(&'a ConditionalGenerateConstruct),
    IfGenerateConstruct(&'a IfGenerateConstruct),
    CaseGenerateConstruct(&'a CaseGenerateConstruct),
    CaseGenerateItem(&'a CaseGenerateItem),
    CaseGenerateItemNondefault(&'a CaseGenerateItemNondefault),
    CaseGenerateItemDefault(&'a CaseGenerateItemDefault),
    GenerateBlock(&'a GenerateBlock),
    GenerateBlockMultiple(&'a GenerateBlockMultiple),
    GenerateItem(&'a GenerateItem),

}


#[derive(Clone, Debug, PartialEq, AnyNode)]
pub enum AnyNode {
    Locate(Locate),
    ArrayIdentifier(ArrayIdentifier),
    BlockIdentifier(BlockIdentifier),
    BinIdentifier(BinIdentifier),
    CIdentifier(CIdentifier),
    CellIdentifier(CellIdentifier),
    CheckerIdentifier(CheckerIdentifier),
    ClassIdentifier(ClassIdentifier),
    ClassVariableIdentifier(ClassVariableIdentifier),
    ClockingIdentifier(ClockingIdentifier),
    ConfigIdentifier(ConfigIdentifier),
    ConstIdentifier(ConstIdentifier),
    ConstraintIdentifier(ConstraintIdentifier),
    CovergroupIdentifier(CovergroupIdentifier),
    CovergroupVariableIdentifier(CovergroupVariableIdentifier),
    CoverPointIdentifier(CoverPointIdentifier),
    CrossIdentifier(CrossIdentifier),
    DynamicArrayVariableIdentifier(DynamicArrayVariableIdentifier),
    EnumIdentifier(EnumIdentifier),
    EscapedIdentifier(EscapedIdentifier),
    FormalIdentifier(FormalIdentifier),
    FormalPortIdentifier(FormalPortIdentifier),
    FunctionIdentifier(FunctionIdentifier),
    GenerateBlockIdentifier(GenerateBlockIdentifier),
    GenvarIdentifier(GenvarIdentifier),
    HierarchicalArrayIdentifier(HierarchicalArrayIdentifier),
    HierarchicalBlockIdentifier(HierarchicalBlockIdentifier),
    HierarchicalEventIdentifier(HierarchicalEventIdentifier),
    HierarchicalIdentifier(HierarchicalIdentifier),
    Root(Root),
    HierarchicalNetIdentifier(HierarchicalNetIdentifier),
    HierarchicalParameterIdentifier(HierarchicalParameterIdentifier),
    HierarchicalPropertyIdentifier(HierarchicalPropertyIdentifier),
    HierarchicalSequenceIdentifier(HierarchicalSequenceIdentifier),
    HierarchicalTaskIdentifier(HierarchicalTaskIdentifier),
    HierarchicalTfIdentifier(HierarchicalTfIdentifier),
    HierarchicalVariableIdentifier(HierarchicalVariableIdentifier),
    Identifier(Identifier),
    IndexVariableIdentifier(IndexVariableIdentifier),
    InterfaceIdentifier(InterfaceIdentifier),
    InterfaceInstanceIdentifier(InterfaceInstanceIdentifier),
    InoutPortIdentifier(InoutPortIdentifier),
    InputPortIdentifier(InputPortIdentifier),
    InstanceIdentifier(InstanceIdentifier),
    LibraryIdentifier(LibraryIdentifier),
    MemberIdentifier(MemberIdentifier),
    MethodIdentifier(MethodIdentifier),
    ModportIdentifier(ModportIdentifier),
    ModuleIdentifier(ModuleIdentifier),
    NetIdentifier(NetIdentifier),
    NetTypeIdentifier(NetTypeIdentifier),
    OutputPortIdentifier(OutputPortIdentifier),
    PackageIdentifier(PackageIdentifier),
    PackageScope(PackageScope),
    PackageScopePackage(PackageScopePackage),
    Unit(Unit),
    ParameterIdentifier(ParameterIdentifier),
    PortIdentifier(PortIdentifier),
    ProductionIdentifier(ProductionIdentifier),
    ProgramIdentifier(ProgramIdentifier),
    PropertyIdentifier(PropertyIdentifier),
    PsClassIdentifier(PsClassIdentifier),
    PsCovergroupIdentifier(PsCovergroupIdentifier),
    PsCheckerIdentifier(PsCheckerIdentifier),
    PsIdentifier(PsIdentifier),
    PsOrHierarchicalArrayIdentifier(PsOrHierarchicalArrayIdentifier),
    PsOrHierarchicalNetIdentifier(PsOrHierarchicalNetIdentifier),
    PsOrHierarchicalNetIdentifierPackageScope(PsOrHierarchicalNetIdentifierPackageScope),
    PsOrHierarchicalNetIdentifierHierarchical(PsOrHierarchicalNetIdentifierHierarchical),
    PsOrHierarchicalPropertyIdentifier(PsOrHierarchicalPropertyIdentifier),
    PsOrHierarchicalPropertyIdentifierPackageScope(PsOrHierarchicalPropertyIdentifierPackageScope),
    PsOrHierarchicalPropertyIdentifierHierarchical(PsOrHierarchicalPropertyIdentifierHierarchical),
    PsOrHierarchicalSequenceIdentifier(PsOrHierarchicalSequenceIdentifier),
    PsOrHierarchicalSequenceIdentifierPackageScope(PsOrHierarchicalSequenceIdentifierPackageScope),
    PsOrHierarchicalSequenceIdentifierHierarchical(PsOrHierarchicalSequenceIdentifierHierarchical),
    PsOrHierarchicalTfIdentifier(PsOrHierarchicalTfIdentifier),
    PsOrHierarchicalTfIdentifierPackageScope(PsOrHierarchicalTfIdentifierPackageScope),
    PsOrHierarchicalTfIdentifierHierarchical(PsOrHierarchicalTfIdentifierHierarchical),
    PsParameterIdentifier(PsParameterIdentifier),
    PsParameterIdentifierScope(PsParameterIdentifierScope),
    PsParameterIdentifierGenerate(PsParameterIdentifierGenerate),
    PsTypeIdentifier(PsTypeIdentifier),
    LocalOrPackageScopeOrClassScope(LocalOrPackageScopeOrClassScope),
    Local(Local),
    SequenceIdentifier(SequenceIdentifier),
    SignalIdentifier(SignalIdentifier),
    SimpleIdentifier(SimpleIdentifier),
    SpecparamIdentifier(SpecparamIdentifier),
    SystemTfIdentifier(SystemTfIdentifier),
    TaskIdentifier(TaskIdentifier),
    TfIdentifier(TfIdentifier),
    TerminalIdentifier(TerminalIdentifier),
    TopmoduleIdentifier(TopmoduleIdentifier),
    TypeIdentifier(TypeIdentifier),
    UdpIdentifier(UdpIdentifier),
    VariableIdentifier(VariableIdentifier),
    ImplicitClassHandleOrClassScopeOrPackageScope(ImplicitClassHandleOrClassScopeOrPackageScope),
    ImplicitClassHandleOrPackageScope(ImplicitClassHandleOrPackageScope),
    ImplicitClassHandleOrClassScope(ImplicitClassHandleOrClassScope),
    PackageScopeOrClassScope(PackageScopeOrClassScope),
    CompilerDirective(CompilerDirective),
    ResetallCompilerDirective(ResetallCompilerDirective),
    IncludeCompilerDirective(IncludeCompilerDirective),
    IncludeCompilerDirectiveDoubleQuote(IncludeCompilerDirectiveDoubleQuote),
    IncludeCompilerDirectiveAngleBracket(IncludeCompilerDirectiveAngleBracket),
    IncludeCompilerDirectiveTextMacroUsage(IncludeCompilerDirectiveTextMacroUsage),
    AngleBracketLiteral(AngleBracketLiteral),
    TextMacroDefinition(TextMacroDefinition),
    TextMacroName(TextMacroName),
    ListOfFormalArguments(ListOfFormalArguments),
    FormalArgument(FormalArgument),
    TextMacroIdentifier(TextMacroIdentifier),
    MacroText(MacroText),
    DefaultText(DefaultText),
    TextMacroUsage(TextMacroUsage),
    ListOfActualArguments(ListOfActualArguments),
    ActualArgument(ActualArgument),
    UndefineCompilerDirective(UndefineCompilerDirective),
    UndefineallCompilerDirective(UndefineallCompilerDirective),
    ConditionalCompilerDirective(ConditionalCompilerDirective),
    IfdefDirective(IfdefDirective),
    IfndefDirective(IfndefDirective),
    IfdefGroupOfLines(IfdefGroupOfLines),
    IfndefGroupOfLines(IfndefGroupOfLines),
    ElsifGroupOfLines(ElsifGroupOfLines),
    ElseGroupOfLines(ElseGroupOfLines),
    SourceDescription(SourceDescription),
    SourceDescriptionNotDirective(SourceDescriptionNotDirective),
    TimescaleCompilerDirective(TimescaleCompilerDirective),
    DefaultNettypeCompilerDirective(DefaultNettypeCompilerDirective),
    DefaultNettypeValue(DefaultNettypeValue),
    UnconnectedDriveCompilerDirective(UnconnectedDriveCompilerDirective),
    NounconnectedDriveCompilerDirective(NounconnectedDriveCompilerDirective),
    CelldefineDriveCompilerDirective(CelldefineDriveCompilerDirective),
    EndcelldefineDriveCompilerDirective(EndcelldefineDriveCompilerDirective),
    Pragma(Pragma),
    PragmaName(PragmaName),
    PragmaExpression(PragmaExpression),
    PragmaExpressionAssignment(PragmaExpressionAssignment),
    PragmaValue(PragmaValue),
    PragmaValueParen(PragmaValueParen),
    PragmaKeyword(PragmaKeyword),
    LineCompilerDirective(LineCompilerDirective),
    PositionCompilerDirective(PositionCompilerDirective),
    Level(Level),
    KeywordsDirective(KeywordsDirective),
    VersionSpecifier(VersionSpecifier),
    EndkeywordsDirective(EndkeywordsDirective),
    Comment(Comment),
    AttributeInstance(AttributeInstance),
    AttrSpec(AttrSpec),
    SourceText(SourceText),
    Description(Description),
    DescriptionPackageItem(DescriptionPackageItem),
    DescriptionBindDirective(DescriptionBindDirective),
    ModuleNonansiHeader(ModuleNonansiHeader),
    ModuleAnsiHeader(ModuleAnsiHeader),
    ModuleDeclaration(ModuleDeclaration),
    ModuleDeclarationNonansi(ModuleDeclarationNonansi),
    ModuleDeclarationAnsi(ModuleDeclarationAnsi),
    ModuleDeclarationWildcard(ModuleDeclarationWildcard),
    ModuleDeclarationExternNonansi(ModuleDeclarationExternNonansi),
    ModuleDeclarationExternAnsi(ModuleDeclarationExternAnsi),
    ModuleKeyword(ModuleKeyword),
    InterfaceDeclaration(InterfaceDeclaration),
    InterfaceDeclarationNonansi(InterfaceDeclarationNonansi),
    InterfaceDeclarationAnsi(InterfaceDeclarationAnsi),
    InterfaceDeclarationWildcard(InterfaceDeclarationWildcard),
    InterfaceDeclarationExternNonansi(InterfaceDeclarationExternNonansi),
    InterfaceDeclarationExternAnsi(InterfaceDeclarationExternAnsi),
    InterfaceNonansiHeader(InterfaceNonansiHeader),
    InterfaceAnsiHeader(InterfaceAnsiHeader),
    ProgramDeclaration(ProgramDeclaration),
    ProgramDeclarationNonansi(ProgramDeclarationNonansi),
    ProgramDeclarationAnsi(ProgramDeclarationAnsi),
    ProgramDeclarationWildcard(ProgramDeclarationWildcard),
    ProgramDeclarationExternNonansi(ProgramDeclarationExternNonansi),
    ProgramDeclarationExternAnsi(ProgramDeclarationExternAnsi),
    ProgramNonansiHeader(ProgramNonansiHeader),
    ProgramAnsiHeader(ProgramAnsiHeader),
    CheckerDeclaration(CheckerDeclaration),
    ClassDeclaration(ClassDeclaration),
    Virtual(Virtual),
    InterfaceClassType(InterfaceClassType),
    InterfaceClassDeclaration(InterfaceClassDeclaration),
    InterfaceClassItem(InterfaceClassItem),
    InterfaceClassItemMethod(InterfaceClassItemMethod),
    InterfaceClassMethod(InterfaceClassMethod),
    PackageDeclaration(PackageDeclaration),
    TimeunitsDeclaration(TimeunitsDeclaration),
    TimeunitsDeclarationTimeunit(TimeunitsDeclarationTimeunit),
    TimeunitsDeclarationTimeprecision(TimeunitsDeclarationTimeprecision),
    TimeunitsDeclarationTimeunitTimeprecision(TimeunitsDeclarationTimeunitTimeprecision),
    TimeunitsDeclarationTimeprecisionTimeunit(TimeunitsDeclarationTimeprecisionTimeunit),
    PackageItem(PackageItem),
    PackageOrGenerateItemDeclaration(PackageOrGenerateItemDeclaration),
    AnonymousProgram(AnonymousProgram),
    AnonymousProgramItem(AnonymousProgramItem),
    ElaborationSystemTask(ElaborationSystemTask),
    ElaborationSystemTaskFatal(ElaborationSystemTaskFatal),
    ElaborationSystemTaskError(ElaborationSystemTaskError),
    ElaborationSystemTaskWarning(ElaborationSystemTaskWarning),
    ElaborationSystemTaskInfo(ElaborationSystemTaskInfo),
    FinishNumber(FinishNumber),
    ModuleCommonItem(ModuleCommonItem),
    ModuleItem(ModuleItem),
    ModuleOrGenerateItem(ModuleOrGenerateItem),
    ModuleOrGenerateItemParameter(ModuleOrGenerateItemParameter),
    ModuleOrGenerateItemGate(ModuleOrGenerateItemGate),
    ModuleOrGenerateItemUdp(ModuleOrGenerateItemUdp),
    ModuleOrGenerateItemModule(ModuleOrGenerateItemModule),
    ModuleOrGenerateItemModuleItem(ModuleOrGenerateItemModuleItem),
    ModuleOrGenerateItemDeclaration(ModuleOrGenerateItemDeclaration),
    ModuleOrGenerateItemDeclarationClocking(ModuleOrGenerateItemDeclarationClocking),
    ModuleOrGenerateItemDeclarationDisable(ModuleOrGenerateItemDeclarationDisable),
    NonPortModuleItem(NonPortModuleItem),
    NonPortModuleItemSpecparam(NonPortModuleItemSpecparam),
    ParameterOverride(ParameterOverride),
    BindDirective(BindDirective),
    BindDirectiveScope(BindDirectiveScope),
    BindDirectiveInstance(BindDirectiveInstance),
    BindTargetScope(BindTargetScope),
    BindTargetInstance(BindTargetInstance),
    BindTargetInstanceList(BindTargetInstanceList),
    BindInstantiation(BindInstantiation),
    ParameterPortList(ParameterPortList),
    ParameterPortListAssignment(ParameterPortListAssignment),
    ParameterPortListDeclaration(ParameterPortListDeclaration),
    ParameterPortDeclaration(ParameterPortDeclaration),
    ParameterPortDeclarationParamList(ParameterPortDeclarationParamList),
    ParameterPortDeclarationTypeList(ParameterPortDeclarationTypeList),
    ListOfPorts(ListOfPorts),
    ListOfPortDeclarations(ListOfPortDeclarations),
    PortDeclaration(PortDeclaration),
    PortDeclarationInout(PortDeclarationInout),
    PortDeclarationInput(PortDeclarationInput),
    PortDeclarationOutput(PortDeclarationOutput),
    PortDeclarationRef(PortDeclarationRef),
    PortDeclarationInterface(PortDeclarationInterface),
    Port(Port),
    PortNonNamed(PortNonNamed),
    PortNamed(PortNamed),
    PortExpression(PortExpression),
    PortExpressionBrace(PortExpressionBrace),
    PortReference(PortReference),
    PortDirection(PortDirection),
    NetPortHeader(NetPortHeader),
    VariablePortHeader(VariablePortHeader),
    InterfacePortHeader(InterfacePortHeader),
    InterfacePortHeaderIdentifier(InterfacePortHeaderIdentifier),
    InterfacePortHeaderInterface(InterfacePortHeaderInterface),
    NetPortHeaderOrInterfacePortHeader(NetPortHeaderOrInterfacePortHeader),
    AnsiPortDeclaration(AnsiPortDeclaration),
    AnsiPortDeclarationNet(AnsiPortDeclarationNet),
    AnsiPortDeclarationVariable(AnsiPortDeclarationVariable),
    AnsiPortDeclarationParen(AnsiPortDeclarationParen),
    CheckerPortList(CheckerPortList),
    CheckerPortItem(CheckerPortItem),
    CheckerPortDirection(CheckerPortDirection),
    CheckerOrGenerateItem(CheckerOrGenerateItem),
    CheckerOrGenerateItemDeclaration(CheckerOrGenerateItemDeclaration),
    CheckerOrGenerateItemDeclarationData(CheckerOrGenerateItemDeclarationData),
    Rand(Rand),
    CheckerOrGenerateItemDeclarationClocking(CheckerOrGenerateItemDeclarationClocking),
    CheckerOrGenerateItemDeclarationDisable(CheckerOrGenerateItemDeclarationDisable),
    CheckerGenerateItem(CheckerGenerateItem),
    ConstraintDeclaration(ConstraintDeclaration),
    Static(Static),
    ConstraintBlock(ConstraintBlock),
    ConstraintBlockItem(ConstraintBlockItem),
    ConstraintBlockItemSolve(ConstraintBlockItemSolve),
    SolveBeforeList(SolveBeforeList),
    ConstraintPrimary(ConstraintPrimary),
    ConstraintExpression(ConstraintExpression),
    ConstraintExpressionExpression(ConstraintExpressionExpression),
    Soft(Soft),
    ConstraintExpressionArrow(ConstraintExpressionArrow),
    ConstraintExpressionIf(ConstraintExpressionIf),
    ConstraintExpressionForeach(ConstraintExpressionForeach),
    ConstraintExpressionDisable(ConstraintExpressionDisable),
    UniquenessConstraint(UniquenessConstraint),
    ConstraintSet(ConstraintSet),
    ConstraintSetBrace(ConstraintSetBrace),
    DistList(DistList),
    DistItem(DistItem),
    DistWeight(DistWeight),
    DistWeightEqual(DistWeightEqual),
    DistWeightDivide(DistWeightDivide),
    ConstraintPrototype(ConstraintPrototype),
    ConstraintPrototypeQualifier(ConstraintPrototypeQualifier),
    ExternConstraintDeclaration(ExternConstraintDeclaration),
    IdentifierList(IdentifierList),
    InterfaceOrGenerateItem(InterfaceOrGenerateItem),
    InterfaceOrGenerateItemModule(InterfaceOrGenerateItemModule),
    InterfaceOrGenerateItemExtern(InterfaceOrGenerateItemExtern),
    ExternTfDeclaration(ExternTfDeclaration),
    ExternTfDeclarationMethod(ExternTfDeclarationMethod),
    ExternTfDeclarationTask(ExternTfDeclarationTask),
    InterfaceItem(InterfaceItem),
    NonPortInterfaceItem(NonPortInterfaceItem),
    ProgramItem(ProgramItem),
    NonPortProgramItem(NonPortProgramItem),
    NonPortProgramItemAssign(NonPortProgramItemAssign),
    NonPortProgramItemModule(NonPortProgramItemModule),
    NonPortProgramItemInitial(NonPortProgramItemInitial),
    NonPortProgramItemFinal(NonPortProgramItemFinal),
    NonPortProgramItemAssertion(NonPortProgramItemAssertion),
    ProgramGenerateItem(ProgramGenerateItem),
    LibraryText(LibraryText),
    LibraryDescription(LibraryDescription),
    LibraryDeclaration(LibraryDeclaration),
    IncludeStatement(IncludeStatement),
    FilePathSpec(FilePathSpec),
    FilePathSpecNonLiteral(FilePathSpecNonLiteral),
    ConfigDeclaration(ConfigDeclaration),
    DesignStatement(DesignStatement),
    ConfigRuleStatement(ConfigRuleStatement),
    ConfigRuleStatementDefault(ConfigRuleStatementDefault),
    ConfigRuleStatementInstLib(ConfigRuleStatementInstLib),
    ConfigRuleStatementInstUse(ConfigRuleStatementInstUse),
    ConfigRuleStatementCellLib(ConfigRuleStatementCellLib),
    ConfigRuleStatementCellUse(ConfigRuleStatementCellUse),
    DefaultClause(DefaultClause),
    InstClause(InstClause),
    InstName(InstName),
    CellClause(CellClause),
    LiblistClause(LiblistClause),
    UseClause(UseClause),
    UseClauseCell(UseClauseCell),
    UseClauseNamed(UseClauseNamed),
    UseClauseCellNamed(UseClauseCellNamed),
    Config(Config),
    ClassItem(ClassItem),
    ClassItemProperty(ClassItemProperty),
    ClassItemMethod(ClassItemMethod),
    ClassItemConstraint(ClassItemConstraint),
    ClassItemDeclaration(ClassItemDeclaration),
    ClassItemCovergroup(ClassItemCovergroup),
    ClassProperty(ClassProperty),
    ClassPropertyNonConst(ClassPropertyNonConst),
    ClassPropertyConst(ClassPropertyConst),
    ClassPropertyConstExpression(ClassPropertyConstExpression),
    ClassMethod(ClassMethod),
    ClassMethodTask(ClassMethodTask),
    ClassMethodFunction(ClassMethodFunction),
    ClassMethodPureVirtual(ClassMethodPureVirtual),
    ClassMethodExternMethod(ClassMethodExternMethod),
    ClassMethodConstructor(ClassMethodConstructor),
    ClassMethodExternConstructor(ClassMethodExternConstructor),
    ClassConstructorPrototype(ClassConstructorPrototype),
    ClassConstraint(ClassConstraint),
    ClassItemQualifier(ClassItemQualifier),
    PropertyQualifier(PropertyQualifier),
    RandomQualifier(RandomQualifier),
    MethodQualifier(MethodQualifier),
    MethodPrototype(MethodPrototype),
    ClassConstructorDeclaration(ClassConstructorDeclaration),
    New(New),
    Number(Number),
    IntegralNumber(IntegralNumber),
    DecimalNumber(DecimalNumber),
    DecimalNumberBaseUnsigned(DecimalNumberBaseUnsigned),
    DecimalNumberBaseXNumber(DecimalNumberBaseXNumber),
    DecimalNumberBaseZNumber(DecimalNumberBaseZNumber),
    BinaryNumber(BinaryNumber),
    OctalNumber(OctalNumber),
    HexNumber(HexNumber),
    Sign(Sign),
    Size(Size),
    NonZeroUnsignedNumber(NonZeroUnsignedNumber),
    RealNumber(RealNumber),
    RealNumberFloating(RealNumberFloating),
    FixedPointNumber(FixedPointNumber),
    Exp(Exp),
    UnsignedNumber(UnsignedNumber),
    BinaryValue(BinaryValue),
    OctalValue(OctalValue),
    HexValue(HexValue),
    DecimalBase(DecimalBase),
    BinaryBase(BinaryBase),
    OctalBase(OctalBase),
    HexBase(HexBase),
    XNumber(XNumber),
    ZNumber(ZNumber),
    UnbasedUnsizedLiteral(UnbasedUnsizedLiteral),
    UnaryOperator(UnaryOperator),
    BinaryOperator(BinaryOperator),
    IncOrDecOperator(IncOrDecOperator),
    UnaryModulePathOperator(UnaryModulePathOperator),
    BinaryModulePathOperator(BinaryModulePathOperator),
    ConstantPrimary(ConstantPrimary),
    ConstantPrimaryPsParameter(ConstantPrimaryPsParameter),
    ConstantPrimarySpecparam(ConstantPrimarySpecparam),
    ConstantPrimaryFormalPort(ConstantPrimaryFormalPort),
    ConstantPrimaryEnum(ConstantPrimaryEnum),
    ConstantPrimaryConcatenation(ConstantPrimaryConcatenation),
    ConstantPrimaryMultipleConcatenation(ConstantPrimaryMultipleConcatenation),
    ConstantPrimaryMintypmaxExpression(ConstantPrimaryMintypmaxExpression),
    ModulePathPrimary(ModulePathPrimary),
    ModulePathPrimaryMintypmax(ModulePathPrimaryMintypmax),
    Primary(Primary),
    PrimaryHierarchical(PrimaryHierarchical),
    PrimaryConcatenation(PrimaryConcatenation),
    PrimaryMultipleConcatenation(PrimaryMultipleConcatenation),
    PrimaryMintypmaxExpression(PrimaryMintypmaxExpression),
    ClassQualifierOrPackageScope(ClassQualifierOrPackageScope),
    ClassQualifier(ClassQualifier),
    RangeExpression(RangeExpression),
    PrimaryLiteral(PrimaryLiteral),
    TimeLiteral(TimeLiteral),
    TimeLiteralUnsigned(TimeLiteralUnsigned),
    TimeLiteralFixedPoint(TimeLiteralFixedPoint),
    TimeUnit(TimeUnit),
    ImplicitClassHandle(ImplicitClassHandle),
    BitSelect(BitSelect),
    Select(Select),
    NonrangeSelect(NonrangeSelect),
    ConstantBitSelect(ConstantBitSelect),
    ConstantSelect(ConstantSelect),
    ConstantCast(ConstantCast),
    ConstantLetExpression(ConstantLetExpression),
    Cast(Cast),
    Concatenation(Concatenation),
    ConstantConcatenation(ConstantConcatenation),
    ConstantMultipleConcatenation(ConstantMultipleConcatenation),
    ModulePathConcatenation(ModulePathConcatenation),
    ModulePathMultipleConcatenation(ModulePathMultipleConcatenation),
    MultipleConcatenation(MultipleConcatenation),
    StreamingConcatenation(StreamingConcatenation),
    StreamOperator(StreamOperator),
    SliceSize(SliceSize),
    StreamConcatenation(StreamConcatenation),
    StreamExpression(StreamExpression),
    ArrayRangeExpression(ArrayRangeExpression),
    ArrayRangeExpressionColon(ArrayRangeExpressionColon),
    ArrayRangeExpressionPlusColon(ArrayRangeExpressionPlusColon),
    ArrayRangeExpressionMinusColon(ArrayRangeExpressionMinusColon),
    EmptyUnpackedArrayConcatenation(EmptyUnpackedArrayConcatenation),
    IncOrDecExpression(IncOrDecExpression),
    IncOrDecExpressionPrefix(IncOrDecExpressionPrefix),
    IncOrDecExpressionSuffix(IncOrDecExpressionSuffix),
    ConditionalExpression(ConditionalExpression),
    ConstantExpression(ConstantExpression),
    ConstantExpressionUnary(ConstantExpressionUnary),
    ConstantExpressionBinary(ConstantExpressionBinary),
    ConstantExpressionTernary(ConstantExpressionTernary),
    ConstantMintypmaxExpression(ConstantMintypmaxExpression),
    ConstantMintypmaxExpressionTernary(ConstantMintypmaxExpressionTernary),
    ConstantParamExpression(ConstantParamExpression),
    ParamExpression(ParamExpression),
    ConstantRangeExpression(ConstantRangeExpression),
    ConstantPartSelectRange(ConstantPartSelectRange),
    ConstantRange(ConstantRange),
    ConstantIndexedRange(ConstantIndexedRange),
    Expression(Expression),
    ExpressionUnary(ExpressionUnary),
    ExpressionOperatorAssignment(ExpressionOperatorAssignment),
    ExpressionBinary(ExpressionBinary),
    TaggedUnionExpression(TaggedUnionExpression),
    InsideExpression(InsideExpression),
    ValueRange(ValueRange),
    ValueRangeBinary(ValueRangeBinary),
    MintypmaxExpression(MintypmaxExpression),
    MintypmaxExpressionTernary(MintypmaxExpressionTernary),
    ModulePathConditionalExpression(ModulePathConditionalExpression),
    ModulePathExpression(ModulePathExpression),
    ModulePathExpressionUnary(ModulePathExpressionUnary),
    ModulePathExpressionBinary(ModulePathExpressionBinary),
    ModulePathMintypmaxExpression(ModulePathMintypmaxExpression),
    ModulePathMintypmaxExpressionTernary(ModulePathMintypmaxExpressionTernary),
    PartSelectRange(PartSelectRange),
    IndexedRange(IndexedRange),
    GenvarExpression(GenvarExpression),
    ConstantFunctionCall(ConstantFunctionCall),
    TfCall(TfCall),
    SystemTfCall(SystemTfCall),
    SystemTfCallArgOptional(SystemTfCallArgOptional),
    SystemTfCallArgDataType(SystemTfCallArgDataType),
    SystemTfCallArgExpression(SystemTfCallArgExpression),
    SubroutineCall(SubroutineCall),
    SubroutineCallRandomize(SubroutineCallRandomize),
    FunctionSubroutineCall(FunctionSubroutineCall),
    ListOfArguments(ListOfArguments),
    ListOfArgumentsOrdered(ListOfArgumentsOrdered),
    ListOfArgumentsNamed(ListOfArgumentsNamed),
    MethodCall(MethodCall),
    MethodCallBody(MethodCallBody),
    MethodCallBodyUser(MethodCallBodyUser),
    BuiltInMethodCall(BuiltInMethodCall),
    ArrayManipulationCall(ArrayManipulationCall),
    RandomizeCall(RandomizeCall),
    VariableIdentifierListOrNull(VariableIdentifierListOrNull),
    MethodCallRoot(MethodCallRoot),
    ArrayMethodName(ArrayMethodName),
    StringLiteral(StringLiteral),
    NetLvalue(NetLvalue),
    NetLvalueIdentifier(NetLvalueIdentifier),
    NetLvalueLvalue(NetLvalueLvalue),
    NetLvaluePattern(NetLvaluePattern),
    VariableLvalue(VariableLvalue),
    VariableLvalueIdentifier(VariableLvalueIdentifier),
    VariableLvalueLvalue(VariableLvalueLvalue),
    VariableLvaluePattern(VariableLvaluePattern),
    NonrangeVariableLvalue(NonrangeVariableLvalue),
    PreprocessorText(PreprocessorText),
    CmosSwitchtype(CmosSwitchtype),
    EnableGatetype(EnableGatetype),
    MosSwitchtype(MosSwitchtype),
    NInputGatetype(NInputGatetype),
    NOutputGatetype(NOutputGatetype),
    PassEnSwitchtype(PassEnSwitchtype),
    PassSwitchtype(PassSwitchtype),
    PulldownStrength(PulldownStrength),
    PulldownStrength01(PulldownStrength01),
    PulldownStrength10(PulldownStrength10),
    PulldownStrength0(PulldownStrength0),
    PullupStrength(PullupStrength),
    PullupStrength01(PullupStrength01),
    PullupStrength10(PullupStrength10),
    PullupStrength1(PullupStrength1),
    EnableTerminal(EnableTerminal),
    InoutTerminal(InoutTerminal),
    InputTerminal(InputTerminal),
    NcontrolTerminal(NcontrolTerminal),
    OutputTerminal(OutputTerminal),
    PcontrolTerminal(PcontrolTerminal),
    GateInstantiation(GateInstantiation),
    GateInstantiationCmos(GateInstantiationCmos),
    GateInstantiationEnable(GateInstantiationEnable),
    GateInstantiationMos(GateInstantiationMos),
    GateInstantiationNInput(GateInstantiationNInput),
    GateInstantiationNOutput(GateInstantiationNOutput),
    GateInstantiationPassEn(GateInstantiationPassEn),
    GateInstantiationPass(GateInstantiationPass),
    GateInstantiationPulldown(GateInstantiationPulldown),
    GateInstantiationPullup(GateInstantiationPullup),
    CmosSwitchInstance(CmosSwitchInstance),
    EnableGateInstance(EnableGateInstance),
    MosSwitchInstance(MosSwitchInstance),
    NInputGateInstance(NInputGateInstance),
    NOutputGateInstance(NOutputGateInstance),
    PassSwitchInstance(PassSwitchInstance),
    PassEnableSwitchInstance(PassEnableSwitchInstance),
    PullGateInstance(PullGateInstance),
    ConcurrentAssertionItem(ConcurrentAssertionItem),
    ConcurrentAssertionItemStatement(ConcurrentAssertionItemStatement),
    ConcurrentAssertionStatement(ConcurrentAssertionStatement),
    AssertPropertyStatement(AssertPropertyStatement),
    AssumePropertyStatement(AssumePropertyStatement),
    CoverPropertyStatement(CoverPropertyStatement),
    ExpectPropertyStatement(ExpectPropertyStatement),
    CoverSequenceStatement(CoverSequenceStatement),
    RestrictPropertyStatement(RestrictPropertyStatement),
    PropertyInstance(PropertyInstance),
    PropertyListOfArguments(PropertyListOfArguments),
    PropertyListOfArgumentsOrdered(PropertyListOfArgumentsOrdered),
    PropertyListOfArgumentsNamed(PropertyListOfArgumentsNamed),
    PropertyActualArg(PropertyActualArg),
    AssertionItemDeclaration(AssertionItemDeclaration),
    PropertyDeclaration(PropertyDeclaration),
    PropertyPortList(PropertyPortList),
    PropertyPortItem(PropertyPortItem),
    PropertyLvarPortDirection(PropertyLvarPortDirection),
    PropertyFormalType(PropertyFormalType),
    PropertySpec(PropertySpec),
    PropertyExpr(PropertyExpr),
    PropertyExprStrong(PropertyExprStrong),
    PropertyExprWeak(PropertyExprWeak),
    PropertyExprParen(PropertyExprParen),
    PropertyExprNot(PropertyExprNot),
    PropertyExprBinaryProperty(PropertyExprBinaryProperty),
    PropertyExprBinarySequence(PropertyExprBinarySequence),
    PropertyExprIf(PropertyExprIf),
    PropertyExprCase(PropertyExprCase),
    PropertyExprNexttime(PropertyExprNexttime),
    PropertyExprSNexttime(PropertyExprSNexttime),
    PropertyExprAlways(PropertyExprAlways),
    PropertyExprSAlways(PropertyExprSAlways),
    PropertyExprEventually(PropertyExprEventually),
    PropertyExprSEventually(PropertyExprSEventually),
    PropertyExprAcceptOn(PropertyExprAcceptOn),
    PropertyExprRejectOn(PropertyExprRejectOn),
    PropertyExprSyncAcceptOn(PropertyExprSyncAcceptOn),
    PropertyExprSyncRejectOn(PropertyExprSyncRejectOn),
    PropertyExprClockingEvent(PropertyExprClockingEvent),
    PropertyCaseItem(PropertyCaseItem),
    PropertyCaseItemNondefault(PropertyCaseItemNondefault),
    PropertyCaseItemDefault(PropertyCaseItemDefault),
    SequenceDeclaration(SequenceDeclaration),
    SequencePortList(SequencePortList),
    SequencePortItem(SequencePortItem),
    SequenceLvarPortDirection(SequenceLvarPortDirection),
    SequenceFormalType(SequenceFormalType),
    SequenceExpr(SequenceExpr),
    SequenceExprCycleDelayExpr(SequenceExprCycleDelayExpr),
    SequenceExprExprCycleDelayExpr(SequenceExprExprCycleDelayExpr),
    SequenceExprExpression(SequenceExprExpression),
    SequenceExprInstance(SequenceExprInstance),
    SequenceExprParen(SequenceExprParen),
    SequenceExprBinary(SequenceExprBinary),
    SequenceExprFirstMatch(SequenceExprFirstMatch),
    SequenceExprThroughout(SequenceExprThroughout),
    SequenceExprClockingEvent(SequenceExprClockingEvent),
    CycleDelayRange(CycleDelayRange),
    CycleDelayRangePrimary(CycleDelayRangePrimary),
    CycleDelayRangeExpression(CycleDelayRangeExpression),
    CycleDelayRangeAsterisk(CycleDelayRangeAsterisk),
    CycleDelayRangePlus(CycleDelayRangePlus),
    SequenceMethodCall(SequenceMethodCall),
    SequenceMatchItem(SequenceMatchItem),
    SequenceInstance(SequenceInstance),
    SequenceListOfArguments(SequenceListOfArguments),
    SequenceListOfArgumentsOrdered(SequenceListOfArgumentsOrdered),
    SequenceListOfArgumentsNamed(SequenceListOfArgumentsNamed),
    SequenceActualArg(SequenceActualArg),
    BooleanAbbrev(BooleanAbbrev),
    SequenceAbbrev(SequenceAbbrev),
    ConsecutiveRepetition(ConsecutiveRepetition),
    ConsecutiveRepetitionExpression(ConsecutiveRepetitionExpression),
    ConsecutiveRepetitionAsterisk(ConsecutiveRepetitionAsterisk),
    ConsecutiveRepetitionPlus(ConsecutiveRepetitionPlus),
    NonConsecutiveRepetition(NonConsecutiveRepetition),
    GotoRepetition(GotoRepetition),
    ConstOrRangeExpression(ConstOrRangeExpression),
    CycleDelayConstRangeExpression(CycleDelayConstRangeExpression),
    CycleDelayConstRangeExpressionBinary(CycleDelayConstRangeExpressionBinary),
    CycleDelayConstRangeExpressionDollar(CycleDelayConstRangeExpressionDollar),
    ExpressionOrDist(ExpressionOrDist),
    AssertionVariableDeclaration(AssertionVariableDeclaration),
    TaskDeclaration(TaskDeclaration),
    TaskBodyDeclaration(TaskBodyDeclaration),
    TaskBodyDeclarationWithoutPort(TaskBodyDeclarationWithoutPort),
    TaskBodyDeclarationWithPort(TaskBodyDeclarationWithPort),
    TfItemDeclaration(TfItemDeclaration),
    TfPortList(TfPortList),
    TfPortItem(TfPortItem),
    TfPortDirection(TfPortDirection),
    TfPortDeclaration(TfPortDeclaration),
    TaskPrototype(TaskPrototype),
    DefparamAssignment(DefparamAssignment),
    NetDeclAssignment(NetDeclAssignment),
    ParamAssignment(ParamAssignment),
    SpecparamAssignment(SpecparamAssignment),
    SpecparamAssignmentMintypmax(SpecparamAssignmentMintypmax),
    TypeAssignment(TypeAssignment),
    PulseControlSpecparam(PulseControlSpecparam),
    PulseControlSpecparamWithoutDescriptor(PulseControlSpecparamWithoutDescriptor),
    PulseControlSpecparamWithDescriptor(PulseControlSpecparamWithDescriptor),
    ErrorLimitValue(ErrorLimitValue),
    RejectLimitValue(RejectLimitValue),
    LimitValue(LimitValue),
    VariableDeclAssignment(VariableDeclAssignment),
    VariableDeclAssignmentVariable(VariableDeclAssignmentVariable),
    VariableDeclAssignmentDynamicArray(VariableDeclAssignmentDynamicArray),
    VariableDeclAssignmentClass(VariableDeclAssignmentClass),
    ClassNew(ClassNew),
    ClassNewArgument(ClassNewArgument),
    ClassNewExpression(ClassNewExpression),
    DynamicArrayNew(DynamicArrayNew),
    ListOfDefparamAssignments(ListOfDefparamAssignments),
    ListOfGenvarIdentifiers(ListOfGenvarIdentifiers),
    ListOfInterfaceIdentifiers(ListOfInterfaceIdentifiers),
    ListOfNetDeclAssignments(ListOfNetDeclAssignments),
    ListOfParamAssignments(ListOfParamAssignments),
    ListOfPortIdentifiers(ListOfPortIdentifiers),
    ListOfUdpPortIdentifiers(ListOfUdpPortIdentifiers),
    ListOfSpecparamAssignments(ListOfSpecparamAssignments),
    ListOfTfVariableIdentifiers(ListOfTfVariableIdentifiers),
    ListOfTypeAssignments(ListOfTypeAssignments),
    ListOfVariableDeclAssignments(ListOfVariableDeclAssignments),
    ListOfVariableIdentifiers(ListOfVariableIdentifiers),
    ListOfVariablePortIdentifiers(ListOfVariablePortIdentifiers),
    DataDeclaration(DataDeclaration),
    DataDeclarationVariable(DataDeclarationVariable),
    Const(Const),
    PackageImportDeclaration(PackageImportDeclaration),
    PackageImportItem(PackageImportItem),
    PackageImportItemIdentifier(PackageImportItemIdentifier),
    PackageImportItemAsterisk(PackageImportItemAsterisk),
    PackageExportDeclaration(PackageExportDeclaration),
    PackageExportDeclarationAsterisk(PackageExportDeclarationAsterisk),
    PackageExportDeclarationItem(PackageExportDeclarationItem),
    GenvarDeclaration(GenvarDeclaration),
    NetDeclaration(NetDeclaration),
    NetDeclarationNetType(NetDeclarationNetType),
    Strength(Strength),
    VectorScalar(VectorScalar),
    NetDeclarationNetTypeIdentifier(NetDeclarationNetTypeIdentifier),
    NetDeclarationInterconnect(NetDeclarationInterconnect),
    TypeDeclaration(TypeDeclaration),
    TypeDeclarationDataType(TypeDeclarationDataType),
    TypeDeclarationInterface(TypeDeclarationInterface),
    TypeDeclarationReserved(TypeDeclarationReserved),
    TypeDeclarationKeyword(TypeDeclarationKeyword),
    NetTypeDeclaration(NetTypeDeclaration),
    NetTypeDeclarationDataType(NetTypeDeclarationDataType),
    NetTypeDeclarationNetType(NetTypeDeclarationNetType),
    Lifetime(Lifetime),
    DriveStrength(DriveStrength),
    DriveStrength01(DriveStrength01),
    DriveStrength10(DriveStrength10),
    DriveStrength0z(DriveStrength0z),
    DriveStrength1z(DriveStrength1z),
    DriveStrengthz1(DriveStrengthz1),
    DriveStrengthz0(DriveStrengthz0),
    Strength0(Strength0),
    Strength1(Strength1),
    ChargeStrength(ChargeStrength),
    ChargeStrengthSmall(ChargeStrengthSmall),
    ChargeStrengthMedium(ChargeStrengthMedium),
    ChargeStrengthLarge(ChargeStrengthLarge),
    LetDeclaration(LetDeclaration),
    LetIdentifier(LetIdentifier),
    LetPortList(LetPortList),
    LetPortItem(LetPortItem),
    LetFormalType(LetFormalType),
    LetExpression(LetExpression),
    LetListOfArguments(LetListOfArguments),
    LetListOfArgumentsOrdered(LetListOfArgumentsOrdered),
    LetListOfArgumentsNamed(LetListOfArgumentsNamed),
    LetActualArg(LetActualArg),
    InoutDeclaration(InoutDeclaration),
    InputDeclaration(InputDeclaration),
    InputDeclarationNet(InputDeclarationNet),
    InputDeclarationVariable(InputDeclarationVariable),
    OutputDeclaration(OutputDeclaration),
    OutputDeclarationNet(OutputDeclarationNet),
    OutputDeclarationVariable(OutputDeclarationVariable),
    InterfacePortDeclaration(InterfacePortDeclaration),
    RefDeclaration(RefDeclaration),
    UnpackedDimension(UnpackedDimension),
    UnpackedDimensionRange(UnpackedDimensionRange),
    UnpackedDimensionExpression(UnpackedDimensionExpression),
    PackedDimension(PackedDimension),
    PackedDimensionRange(PackedDimensionRange),
    AssociativeDimension(AssociativeDimension),
    AssociativeDimensionDataType(AssociativeDimensionDataType),
    AssociativeDimensionAsterisk(AssociativeDimensionAsterisk),
    VariableDimension(VariableDimension),
    QueueDimension(QueueDimension),
    UnsizedDimension(UnsizedDimension),
    LocalParameterDeclaration(LocalParameterDeclaration),
    LocalParameterDeclarationParam(LocalParameterDeclarationParam),
    LocalParameterDeclarationType(LocalParameterDeclarationType),
    ParameterDeclaration(ParameterDeclaration),
    ParameterDeclarationParam(ParameterDeclarationParam),
    ParameterDeclarationType(ParameterDeclarationType),
    SpecparamDeclaration(SpecparamDeclaration),
    CovergroupDeclaration(CovergroupDeclaration),
    CoverageSpecOrOption(CoverageSpecOrOption),
    CoverageSpecOrOptionSpec(CoverageSpecOrOptionSpec),
    CoverageSpecOrOptionOption(CoverageSpecOrOptionOption),
    CoverageOption(CoverageOption),
    CoverageOptionOption(CoverageOptionOption),
    CoverageOptionTypeOption(CoverageOptionTypeOption),
    CoverageSpec(CoverageSpec),
    CoverageEvent(CoverageEvent),
    CoverageEventSample(CoverageEventSample),
    CoverageEventAt(CoverageEventAt),
    BlockEventExpression(BlockEventExpression),
    BlockEventExpressionOr(BlockEventExpressionOr),
    BlockEventExpressionBegin(BlockEventExpressionBegin),
    BlockEventExpressionEnd(BlockEventExpressionEnd),
    HierarchicalBtfIdentifier(HierarchicalBtfIdentifier),
    HierarchicalBtfIdentifierMethod(HierarchicalBtfIdentifierMethod),
    HierarchicalIdentifierOrClassScope(HierarchicalIdentifierOrClassScope),
    CoverPoint(CoverPoint),
    BinsOrEmpty(BinsOrEmpty),
    BinsOrEmptyNonEmpty(BinsOrEmptyNonEmpty),
    BinsOrOptions(BinsOrOptions),
    BinsOrOptionsCovergroup(BinsOrOptionsCovergroup),
    Wildcard(Wildcard),
    BinsOrOptionsCoverPoint(BinsOrOptionsCoverPoint),
    BinsOrOptionsSetCovergroup(BinsOrOptionsSetCovergroup),
    BinsOrOptionsTransList(BinsOrOptionsTransList),
    BinsOrOptionsDefault(BinsOrOptionsDefault),
    BinsOrOptionsDefaultSequence(BinsOrOptionsDefaultSequence),
    BinsKeyword(BinsKeyword),
    TransList(TransList),
    TransSet(TransSet),
    TransRangeList(TransRangeList),
    TransRangeListAsterisk(TransRangeListAsterisk),
    TransRangeListArrow(TransRangeListArrow),
    TransRangeListEqual(TransRangeListEqual),
    TransItem(TransItem),
    RepeatRange(RepeatRange),
    RepeatRangeBinary(RepeatRangeBinary),
    CoverCross(CoverCross),
    ListOfCrossItems(ListOfCrossItems),
    CrossItem(CrossItem),
    CrossBody(CrossBody),
    CrossBodyNonEmpty(CrossBodyNonEmpty),
    CrossBodyItem(CrossBodyItem),
    BinsSelectionOrOption(BinsSelectionOrOption),
    BinsSelectionOrOptionCoverage(BinsSelectionOrOptionCoverage),
    BinsSelectionOrOptionBins(BinsSelectionOrOptionBins),
    BinsSelection(BinsSelection),
    SelectExpression(SelectExpression),
    SelectExpressionNot(SelectExpressionNot),
    SelectExpressionAnd(SelectExpressionAnd),
    SelectExpressionOr(SelectExpressionOr),
    SelectExpressionParen(SelectExpressionParen),
    SelectExpressionWith(SelectExpressionWith),
    SelectExpressionCrossSet(SelectExpressionCrossSet),
    SelectCondition(SelectCondition),
    BinsExpression(BinsExpression),
    BinsExpressionCoverPoint(BinsExpressionCoverPoint),
    CovergroupRangeList(CovergroupRangeList),
    CovergroupValueRange(CovergroupValueRange),
    CovergroupValueRangeBinary(CovergroupValueRangeBinary),
    WithCovergroupExpression(WithCovergroupExpression),
    SetCovergroupExpression(SetCovergroupExpression),
    IntegerCovergroupExpression(IntegerCovergroupExpression),
    CrossSetExpression(CrossSetExpression),
    CovergroupExpression(CovergroupExpression),
    BlockItemDeclaration(BlockItemDeclaration),
    BlockItemDeclarationData(BlockItemDeclarationData),
    BlockItemDeclarationLocalParameter(BlockItemDeclarationLocalParameter),
    BlockItemDeclarationParameter(BlockItemDeclarationParameter),
    BlockItemDeclarationLet(BlockItemDeclarationLet),
    Delay3(Delay3),
    Delay3Single(Delay3Single),
    Delay3Mintypmax(Delay3Mintypmax),
    Delay2(Delay2),
    Delay2Single(Delay2Single),
    Delay2Mintypmax(Delay2Mintypmax),
    DelayValue(DelayValue),
    ModportDeclaration(ModportDeclaration),
    ModportItem(ModportItem),
    ModportPortsDeclaration(ModportPortsDeclaration),
    ModportPortsDeclarationSimple(ModportPortsDeclarationSimple),
    ModportPortsDeclarationTf(ModportPortsDeclarationTf),
    ModportPortsDeclarationClocking(ModportPortsDeclarationClocking),
    ModportClockingDeclaration(ModportClockingDeclaration),
    ModportSimplePortsDeclaration(ModportSimplePortsDeclaration),
    ModportSimplePort(ModportSimplePort),
    ModportSimplePortOrdered(ModportSimplePortOrdered),
    ModportSimplePortNamed(ModportSimplePortNamed),
    ModportTfPortsDeclaration(ModportTfPortsDeclaration),
    ModportTfPort(ModportTfPort),
    ImportExport(ImportExport),
    CastingType(CastingType),
    DataType(DataType),
    DataTypeVector(DataTypeVector),
    DataTypeAtom(DataTypeAtom),
    DataTypeStructUnion(DataTypeStructUnion),
    Packed(Packed),
    DataTypeEnum(DataTypeEnum),
    DataTypeVirtual(DataTypeVirtual),
    Interface(Interface),
    DataTypeType(DataTypeType),
    DataTypeOrImplicit(DataTypeOrImplicit),
    ImplicitDataType(ImplicitDataType),
    EnumBaseType(EnumBaseType),
    EnumBaseTypeAtom(EnumBaseTypeAtom),
    EnumBaseTypeVector(EnumBaseTypeVector),
    EnumBaseTypeType(EnumBaseTypeType),
    EnumNameDeclaration(EnumNameDeclaration),
    ClassScope(ClassScope),
    ClassType(ClassType),
    IntegerType(IntegerType),
    IntegerAtomType(IntegerAtomType),
    IntegerVectorType(IntegerVectorType),
    NonIntegerType(NonIntegerType),
    NetType(NetType),
    NetPortType(NetPortType),
    NetPortTypeDataType(NetPortTypeDataType),
    NetPortTypeInterconnect(NetPortTypeInterconnect),
    VariablePortType(VariablePortType),
    VarDataType(VarDataType),
    VarDataTypeVar(VarDataTypeVar),
    Signing(Signing),
    SimpleType(SimpleType),
    StructUnionMember(StructUnionMember),
    DataTypeOrVoid(DataTypeOrVoid),
    StructUnion(StructUnion),
    TypeReference(TypeReference),
    TypeReferenceExpression(TypeReferenceExpression),
    TypeReferenceDataType(TypeReferenceDataType),
    FunctionDataTypeOrImplicit(FunctionDataTypeOrImplicit),
    FunctionDeclaration(FunctionDeclaration),
    FunctionBodyDeclaration(FunctionBodyDeclaration),
    FunctionBodyDeclarationWithoutPort(FunctionBodyDeclarationWithoutPort),
    FunctionBodyDeclarationWithPort(FunctionBodyDeclarationWithPort),
    InterfaceIdentifierOrClassScope(InterfaceIdentifierOrClassScope),
    FunctionPrototype(FunctionPrototype),
    DpiImportExport(DpiImportExport),
    DpiImportExportImportFunction(DpiImportExportImportFunction),
    DpiImportExportImportTask(DpiImportExportImportTask),
    DpiImportExportExportFunction(DpiImportExportExportFunction),
    DpiImportExportExportTask(DpiImportExportExportTask),
    DpiSpecString(DpiSpecString),
    DpiFunctionImportProperty(DpiFunctionImportProperty),
    DpiTaskImportProperty(DpiTaskImportProperty),
    DpiFunctionProto(DpiFunctionProto),
    DpiTaskProto(DpiTaskProto),
    Symbol(Symbol),
    Keyword(Keyword),
    WhiteSpace(WhiteSpace),
    TimingCheckEvent(TimingCheckEvent),
    ControlledTimingCheckEvent(ControlledTimingCheckEvent),
    TimingCheckEventControl(TimingCheckEventControl),
    SpecifyTerminalDescriptor(SpecifyTerminalDescriptor),
    EdgeControlSpecifier(EdgeControlSpecifier),
    EdgeDescriptor(EdgeDescriptor),
    TimingCheckCondition(TimingCheckCondition),
    TimingCheckConditionParen(TimingCheckConditionParen),
    ScalarTimingCheckCondition(ScalarTimingCheckCondition),
    ScalarTimingCheckConditionUnary(ScalarTimingCheckConditionUnary),
    ScalarTimingCheckConditionBinary(ScalarTimingCheckConditionBinary),
    ScalarConstant(ScalarConstant),
    SpecifyBlock(SpecifyBlock),
    SpecifyItem(SpecifyItem),
    PulsestyleDeclaration(PulsestyleDeclaration),
    ShowcancelledDeclaration(ShowcancelledDeclaration),
    SystemTimingCheck(SystemTimingCheck),
    SetupTimingCheck(SetupTimingCheck),
    HoldTimingCheck(HoldTimingCheck),
    SetupholdTimingCheck(SetupholdTimingCheck),
    RecoveryTimingCheck(RecoveryTimingCheck),
    RemovalTimingCheck(RemovalTimingCheck),
    RecremTimingCheck(RecremTimingCheck),
    SkewTimingCheck(SkewTimingCheck),
    TimeskewTimingCheck(TimeskewTimingCheck),
    FullskewTimingCheck(FullskewTimingCheck),
    PeriodTimingCheck(PeriodTimingCheck),
    WidthTimingCheck(WidthTimingCheck),
    NochangeTimingCheck(NochangeTimingCheck),
    PathDelayValue(PathDelayValue),
    PathDelayValueParen(PathDelayValueParen),
    ListOfPathDelayExpressions(ListOfPathDelayExpressions),
    TPathDelayExpression(TPathDelayExpression),
    PathDelayExpression(PathDelayExpression),
    EdgeSensitivePathDeclaration(EdgeSensitivePathDeclaration),
    EdgeSensitivePathDeclarationParallel(EdgeSensitivePathDeclarationParallel),
    EdgeSensitivePathDeclarationFull(EdgeSensitivePathDeclarationFull),
    ParallelEdgeSensitivePathDescription(ParallelEdgeSensitivePathDescription),
    FullEdgeSensitivePathDescription(FullEdgeSensitivePathDescription),
    DataSourceExpression(DataSourceExpression),
    EdgeIdentifier(EdgeIdentifier),
    StateDependentPathDeclaration(StateDependentPathDeclaration),
    StateDependentPathDeclarationIfSimple(StateDependentPathDeclarationIfSimple),
    StateDependentPathDeclarationIfEdgeSensitive(StateDependentPathDeclarationIfEdgeSensitive),
    StateDependentPathDeclarationIfNone(StateDependentPathDeclarationIfNone),
    PolarityOperator(PolarityOperator),
    TimecheckCondition(TimecheckCondition),
    ControlledReferenceEvent(ControlledReferenceEvent),
    DataEvent(DataEvent),
    DelayedData(DelayedData),
    DelayedDataWithMintypmax(DelayedDataWithMintypmax),
    DelayedReference(DelayedReference),
    DelayedReferenceWithMintypmax(DelayedReferenceWithMintypmax),
    EndEdgeOffset(EndEdgeOffset),
    EventBasedFlag(EventBasedFlag),
    Notifier(Notifier),
    ReferenceEvent(ReferenceEvent),
    RemainActiveFlag(RemainActiveFlag),
    TimestampCondition(TimestampCondition),
    StartEdgeOffset(StartEdgeOffset),
    Threshold(Threshold),
    TimingCheckLimit(TimingCheckLimit),
    PathDeclaration(PathDeclaration),
    SimplePathDeclaration(SimplePathDeclaration),
    SimplePathDeclarationParallel(SimplePathDeclarationParallel),
    SimplePathDeclarationFull(SimplePathDeclarationFull),
    ParallelPathDescription(ParallelPathDescription),
    FullPathDescription(FullPathDescription),
    ListOfPathInputs(ListOfPathInputs),
    ListOfPathOutputs(ListOfPathOutputs),
    SpecifyInputTerminalDescriptor(SpecifyInputTerminalDescriptor),
    SpecifyOutputTerminalDescriptor(SpecifyOutputTerminalDescriptor),
    InputIdentifier(InputIdentifier),
    InputIdentifierInterface(InputIdentifierInterface),
    OutputIdentifier(OutputIdentifier),
    OutputIdentifierInterface(OutputIdentifierInterface),
    LoopStatement(LoopStatement),
    LoopStatementForever(LoopStatementForever),
    LoopStatementRepeat(LoopStatementRepeat),
    LoopStatementWhile(LoopStatementWhile),
    LoopStatementFor(LoopStatementFor),
    LoopStatementDoWhile(LoopStatementDoWhile),
    LoopStatementForeach(LoopStatementForeach),
    ForInitialization(ForInitialization),
    ForInitializationDeclaration(ForInitializationDeclaration),
    ForVariableDeclaration(ForVariableDeclaration),
    Var(Var),
    ForStep(ForStep),
    ForStepAssignment(ForStepAssignment),
    LoopVariables(LoopVariables),
    CaseStatement(CaseStatement),
    CaseStatementNormal(CaseStatementNormal),
    CaseStatementMatches(CaseStatementMatches),
    CaseStatementInside(CaseStatementInside),
    CaseKeyword(CaseKeyword),
    CaseExpression(CaseExpression),
    CaseItem(CaseItem),
    CaseItemNondefault(CaseItemNondefault),
    CaseItemDefault(CaseItemDefault),
    CasePatternItem(CasePatternItem),
    CasePatternItemNondefault(CasePatternItemNondefault),
    CaseInsideItem(CaseInsideItem),
    CaseInsideItemNondefault(CaseInsideItemNondefault),
    CaseItemExpression(CaseItemExpression),
    RandcaseStatement(RandcaseStatement),
    RandcaseItem(RandcaseItem),
    OpenRangeList(OpenRangeList),
    OpenValueRange(OpenValueRange),
    ContinuousAssign(ContinuousAssign),
    ContinuousAssignNet(ContinuousAssignNet),
    ContinuousAssignVariable(ContinuousAssignVariable),
    ListOfNetAssignments(ListOfNetAssignments),
    ListOfVariableAssignments(ListOfVariableAssignments),
    NetAlias(NetAlias),
    NetAssignment(NetAssignment),
    ConditionalStatement(ConditionalStatement),
    UniquePriority(UniquePriority),
    CondPredicate(CondPredicate),
    ExpressionOrCondPattern(ExpressionOrCondPattern),
    CondPattern(CondPattern),
    ProceduralTimingControlStatement(ProceduralTimingControlStatement),
    DelayOrEventControl(DelayOrEventControl),
    DelayOrEventControlRepeat(DelayOrEventControlRepeat),
    DelayControl(DelayControl),
    DelayControlDelay(DelayControlDelay),
    DelayControlMintypmax(DelayControlMintypmax),
    EventControl(EventControl),
    EventControlEventIdentifier(EventControlEventIdentifier),
    EventControlEventExpression(EventControlEventExpression),
    EventControlAsterisk(EventControlAsterisk),
    EventControlParenAsterisk(EventControlParenAsterisk),
    EventControlSequenceIdentifier(EventControlSequenceIdentifier),
    EventExpression(EventExpression),
    EventExpressionExpression(EventExpressionExpression),
    EventExpressionSequence(EventExpressionSequence),
    EventExpressionOr(EventExpressionOr),
    EventExpressionComma(EventExpressionComma),
    EventExpressionParen(EventExpressionParen),
    ProceduralTimingControl(ProceduralTimingControl),
    JumpStatement(JumpStatement),
    JumpStatementReturn(JumpStatementReturn),
    JumpStatementBreak(JumpStatementBreak),
    JumpStatementContinue(JumpStatementContinue),
    WaitStatement(WaitStatement),
    WaitStatementWait(WaitStatementWait),
    WaitStatementFork(WaitStatementFork),
    WaitStatementOrder(WaitStatementOrder),
    EventTrigger(EventTrigger),
    EventTriggerNamed(EventTriggerNamed),
    EventTriggerNonblocking(EventTriggerNonblocking),
    DisableStatement(DisableStatement),
    DisableStatementTask(DisableStatementTask),
    DisableStatementBlock(DisableStatementBlock),
    DisableStatementFork(DisableStatementFork),
    RandsequenceStatement(RandsequenceStatement),
    Production(Production),
    RsRule(RsRule),
    RsProductionList(RsProductionList),
    RsProductionListProd(RsProductionListProd),
    RsProductionListJoin(RsProductionListJoin),
    WeightSpecification(WeightSpecification),
    WeightSpecificationExpression(WeightSpecificationExpression),
    RsCodeBlock(RsCodeBlock),
    RsProd(RsProd),
    ProductionItem(ProductionItem),
    RsIfElse(RsIfElse),
    RsRepeat(RsRepeat),
    RsCase(RsCase),
    RsCaseItem(RsCaseItem),
    RsCaseItemNondefault(RsCaseItemNondefault),
    RsCaseItemDefault(RsCaseItemDefault),
    Pattern(Pattern),
    PatternVariable(PatternVariable),
    PatternTagged(PatternTagged),
    PatternList(PatternList),
    PatternIdentifierList(PatternIdentifierList),
    AssignmentPattern(AssignmentPattern),
    AssignmentPatternList(AssignmentPatternList),
    AssignmentPatternStructure(AssignmentPatternStructure),
    AssignmentPatternArray(AssignmentPatternArray),
    AssignmentPatternRepeat(AssignmentPatternRepeat),
    StructurePatternKey(StructurePatternKey),
    ArrayPatternKey(ArrayPatternKey),
    AssignmentPatternKey(AssignmentPatternKey),
    AssignmentPatternExpression(AssignmentPatternExpression),
    AssignmentPatternExpressionType(AssignmentPatternExpressionType),
    ConstantAssignmentPatternExpression(ConstantAssignmentPatternExpression),
    AssignmentPatternNetLvalue(AssignmentPatternNetLvalue),
    AssignmentPatternVariableLvalue(AssignmentPatternVariableLvalue),
    AssertionItem(AssertionItem),
    DeferredImmediateAssetionItem(DeferredImmediateAssetionItem),
    ProceduralAssertionStatement(ProceduralAssertionStatement),
    ImmediateAssetionStatement(ImmediateAssetionStatement),
    SimpleImmediateAssertionStatement(SimpleImmediateAssertionStatement),
    SimpleImmediateAssertStatement(SimpleImmediateAssertStatement),
    SimpleImmediateAssumeStatement(SimpleImmediateAssumeStatement),
    SimpleImmediateCoverStatement(SimpleImmediateCoverStatement),
    DeferredImmediateAssertionStatement(DeferredImmediateAssertionStatement),
    DeferredImmediateAssertStatement(DeferredImmediateAssertStatement),
    DeferredImmediateAssumeStatement(DeferredImmediateAssumeStatement),
    DeferredImmediateCoverStatement(DeferredImmediateCoverStatement),
    AssertTiming(AssertTiming),
    InitialConstruct(InitialConstruct),
    AlwaysConstruct(AlwaysConstruct),
    AlwaysKeyword(AlwaysKeyword),
    FinalConstruct(FinalConstruct),
    BlockingAssignment(BlockingAssignment),
    BlockingAssignmentVariable(BlockingAssignmentVariable),
    BlockingAssignmentNonrangeVariable(BlockingAssignmentNonrangeVariable),
    BlockingAssignmentHierarchicalVariable(BlockingAssignmentHierarchicalVariable),
    OperatorAssignment(OperatorAssignment),
    AssignmentOperator(AssignmentOperator),
    NonblockingAssignment(NonblockingAssignment),
    ProceduralContinuousAssignment(ProceduralContinuousAssignment),
    ProceduralContinuousAssignmentAssign(ProceduralContinuousAssignmentAssign),
    ProceduralContinuousAssignmentDeassign(ProceduralContinuousAssignmentDeassign),
    ProceduralContinuousAssignmentForceVariable(ProceduralContinuousAssignmentForceVariable),
    ProceduralContinuousAssignmentForceNet(ProceduralContinuousAssignmentForceNet),
    ProceduralContinuousAssignmentReleaseVariable(ProceduralContinuousAssignmentReleaseVariable),
    ProceduralContinuousAssignmentReleaseNet(ProceduralContinuousAssignmentReleaseNet),
    VariableAssignment(VariableAssignment),
    SubroutineCallStatement(SubroutineCallStatement),
    SubroutineCallStatementFunction(SubroutineCallStatementFunction),
    ClockingDeclaration(ClockingDeclaration),
    ClockingDeclarationLocal(ClockingDeclarationLocal),
    Default(Default),
    ClockingDeclarationGlobal(ClockingDeclarationGlobal),
    ClockingEvent(ClockingEvent),
    ClockingEventIdentifier(ClockingEventIdentifier),
    ClockingEventExpression(ClockingEventExpression),
    ClockingItem(ClockingItem),
    ClockingItemDefault(ClockingItemDefault),
    ClockingItemDirection(ClockingItemDirection),
    ClockingItemAssertion(ClockingItemAssertion),
    DefaultSkew(DefaultSkew),
    DefaultSkewInput(DefaultSkewInput),
    DefaultSkewOutput(DefaultSkewOutput),
    DefaultSkewInputOutput(DefaultSkewInputOutput),
    ClockingDirection(ClockingDirection),
    ClockingDirectionInput(ClockingDirectionInput),
    ClockingDirectionOutput(ClockingDirectionOutput),
    ClockingDirectionInputOutput(ClockingDirectionInputOutput),
    ListOfClockingDeclAssign(ListOfClockingDeclAssign),
    ClockingDeclAssign(ClockingDeclAssign),
    ClockingSkew(ClockingSkew),
    ClockingSkewEdge(ClockingSkewEdge),
    ClockingDrive(ClockingDrive),
    CycleDelay(CycleDelay),
    CycleDelayIntegral(CycleDelayIntegral),
    CycleDelayIdentifier(CycleDelayIdentifier),
    CycleDelayExpression(CycleDelayExpression),
    Clockvar(Clockvar),
    ClockvarExpression(ClockvarExpression),
    ActionBlock(ActionBlock),
    ActionBlockElse(ActionBlockElse),
    SeqBlock(SeqBlock),
    ParBlock(ParBlock),
    JoinKeyword(JoinKeyword),
    StatementOrNull(StatementOrNull),
    StatementOrNullAttribute(StatementOrNullAttribute),
    Statement(Statement),
    StatementItem(StatementItem),
    FunctionStatement(FunctionStatement),
    FunctionStatementOrNull(FunctionStatementOrNull),
    FunctionStatementOrNullAttribute(FunctionStatementOrNullAttribute),
    VariableIdentifierList(VariableIdentifierList),
    UdpInstantiation(UdpInstantiation),
    UdpInstance(UdpInstance),
    UdpNonansiDeclaration(UdpNonansiDeclaration),
    UdpAnsiDeclaration(UdpAnsiDeclaration),
    UdpDeclaration(UdpDeclaration),
    UdpDeclarationNonansi(UdpDeclarationNonansi),
    UdpDeclarationAnsi(UdpDeclarationAnsi),
    UdpDeclarationExternNonansi(UdpDeclarationExternNonansi),
    UdpDeclarationExternAnsi(UdpDeclarationExternAnsi),
    UdpDeclarationWildcard(UdpDeclarationWildcard),
    UdpBody(UdpBody),
    CombinationalBody(CombinationalBody),
    CombinationalEntry(CombinationalEntry),
    SequentialBody(SequentialBody),
    UdpInitialStatement(UdpInitialStatement),
    InitVal(InitVal),
    SequentialEntry(SequentialEntry),
    SeqInputList(SeqInputList),
    LevelInputList(LevelInputList),
    EdgeInputList(EdgeInputList),
    EdgeIndicator(EdgeIndicator),
    EdgeIndicatorParen(EdgeIndicatorParen),
    CurrentState(CurrentState),
    NextState(NextState),
    OutputSymbol(OutputSymbol),
    LevelSymbol(LevelSymbol),
    EdgeSymbol(EdgeSymbol),
    UdpPortList(UdpPortList),
    UdpDeclarationPortList(UdpDeclarationPortList),
    UdpPortDeclaration(UdpPortDeclaration),
    UdpOutputDeclaration(UdpOutputDeclaration),
    UdpOutputDeclarationNonreg(UdpOutputDeclarationNonreg),
    UdpOutputDeclarationReg(UdpOutputDeclarationReg),
    UdpInputDeclaration(UdpInputDeclaration),
    UdpRegDeclaration(UdpRegDeclaration),
    InterfaceInstantiation(InterfaceInstantiation),
    CheckerInstantiation(CheckerInstantiation),
    ListOfCheckerPortConnections(ListOfCheckerPortConnections),
    ListOfCheckerPortConnectionsOrdered(ListOfCheckerPortConnectionsOrdered),
    ListOfCheckerPortConnectionsNamed(ListOfCheckerPortConnectionsNamed),
    OrderedCheckerPortConnection(OrderedCheckerPortConnection),
    NamedCheckerPortConnection(NamedCheckerPortConnection),
    NamedCheckerPortConnectionIdentifier(NamedCheckerPortConnectionIdentifier),
    NamedCheckerPortConnectionAsterisk(NamedCheckerPortConnectionAsterisk),
    ModuleInstantiation(ModuleInstantiation),
    ParameterValueAssignment(ParameterValueAssignment),
    ListOfParameterAssignments(ListOfParameterAssignments),
    ListOfParameterAssignmentsOrdered(ListOfParameterAssignmentsOrdered),
    ListOfParameterAssignmentsNamed(ListOfParameterAssignmentsNamed),
    OrderedParameterAssignment(OrderedParameterAssignment),
    NamedParameterAssignment(NamedParameterAssignment),
    HierarchicalInstance(HierarchicalInstance),
    NameOfInstance(NameOfInstance),
    ListOfPortConnections(ListOfPortConnections),
    ListOfPortConnectionsOrdered(ListOfPortConnectionsOrdered),
    ListOfPortConnectionsNamed(ListOfPortConnectionsNamed),
    OrderedPortConnection(OrderedPortConnection),
    NamedPortConnection(NamedPortConnection),
    NamedPortConnectionIdentifier(NamedPortConnectionIdentifier),
    NamedPortConnectionAsterisk(NamedPortConnectionAsterisk),
    ProgramInstantiation(ProgramInstantiation),
    GenerateRegion(GenerateRegion),
    LoopGenerateConstruct(LoopGenerateConstruct),
    GenvarInitialization(GenvarInitialization),
    Genvar(Genvar),
    GenvarIteration(GenvarIteration),
    GenvarIterationAssignment(GenvarIterationAssignment),
    GenvarIterationPrefix(GenvarIterationPrefix),
    GenvarIterationSuffix(GenvarIterationSuffix),
    ConditionalGenerateConstruct(ConditionalGenerateConstruct),
    IfGenerateConstruct(IfGenerateConstruct),
    CaseGenerateConstruct(CaseGenerateConstruct),
    CaseGenerateItem(CaseGenerateItem),
    CaseGenerateItemNondefault(CaseGenerateItemNondefault),
    CaseGenerateItemDefault(CaseGenerateItemDefault),
    GenerateBlock(GenerateBlock),
    GenerateBlockMultiple(GenerateBlockMultiple),
    GenerateItem(GenerateItem),

}


impl<'a> std::fmt::Display for RefNode<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RefNode::Locate(_) => write!(f, "Locate"),
            RefNode::ArrayIdentifier(_) => write!(f, "ArrayIdentifier"),
            RefNode::BlockIdentifier(_) => write!(f, "BlockIdentifier"),
            RefNode::BinIdentifier(_) => write!(f, "BinIdentifier"),
            RefNode::CIdentifier(_) => write!(f, "CIdentifier"),
            RefNode::CellIdentifier(_) => write!(f, "CellIdentifier"),
            RefNode::CheckerIdentifier(_) => write!(f, "CheckerIdentifier"),
            RefNode::ClassIdentifier(_) => write!(f, "ClassIdentifier"),
            RefNode::ClassVariableIdentifier(_) => write!(f, "ClassVariableIdentifier"),
            RefNode::ClockingIdentifier(_) => write!(f, "ClockingIdentifier"),
            RefNode::ConfigIdentifier(_) => write!(f, "ConfigIdentifier"),
            RefNode::ConstIdentifier(_) => write!(f, "ConstIdentifier"),
            RefNode::ConstraintIdentifier(_) => write!(f, "ConstraintIdentifier"),
            RefNode::CovergroupIdentifier(_) => write!(f, "CovergroupIdentifier"),
            RefNode::CovergroupVariableIdentifier(_) => write!(f, "CovergroupVariableIdentifier"),
            RefNode::CoverPointIdentifier(_) => write!(f, "CoverPointIdentifier"),
            RefNode::CrossIdentifier(_) => write!(f, "CrossIdentifier"),
            RefNode::DynamicArrayVariableIdentifier(_) => write!(f, "DynamicArrayVariableIdentifier"),
            RefNode::EnumIdentifier(_) => write!(f, "EnumIdentifier"),
            RefNode::EscapedIdentifier(_) => write!(f, "EscapedIdentifier"),
            RefNode::FormalIdentifier(_) => write!(f, "FormalIdentifier"),
            RefNode::FormalPortIdentifier(_) => write!(f, "FormalPortIdentifier"),
            RefNode::FunctionIdentifier(_) => write!(f, "FunctionIdentifier"),
            RefNode::GenerateBlockIdentifier(_) => write!(f, "GenerateBlockIdentifier"),
            RefNode::GenvarIdentifier(_) => write!(f, "GenvarIdentifier"),
            RefNode::HierarchicalArrayIdentifier(_) => write!(f, "HierarchicalArrayIdentifier"),
            RefNode::HierarchicalBlockIdentifier(_) => write!(f, "HierarchicalBlockIdentifier"),
            RefNode::HierarchicalEventIdentifier(_) => write!(f, "HierarchicalEventIdentifier"),
            RefNode::HierarchicalIdentifier(_) => write!(f, "HierarchicalIdentifier"),
            RefNode::Root(_) => write!(f, "Root"),
            RefNode::HierarchicalNetIdentifier(_) => write!(f, "HierarchicalNetIdentifier"),
            RefNode::HierarchicalParameterIdentifier(_) => write!(f, "HierarchicalParameterIdentifier"),
            RefNode::HierarchicalPropertyIdentifier(_) => write!(f, "HierarchicalPropertyIdentifier"),
            RefNode::HierarchicalSequenceIdentifier(_) => write!(f, "HierarchicalSequenceIdentifier"),
            RefNode::HierarchicalTaskIdentifier(_) => write!(f, "HierarchicalTaskIdentifier"),
            RefNode::HierarchicalTfIdentifier(_) => write!(f, "HierarchicalTfIdentifier"),
            RefNode::HierarchicalVariableIdentifier(_) => write!(f, "HierarchicalVariableIdentifier"),
            RefNode::Identifier(_) => write!(f, "Identifier"),
            RefNode::IndexVariableIdentifier(_) => write!(f, "IndexVariableIdentifier"),
            RefNode::InterfaceIdentifier(_) => write!(f, "InterfaceIdentifier"),
            RefNode::InterfaceInstanceIdentifier(_) => write!(f, "InterfaceInstanceIdentifier"),
            RefNode::InoutPortIdentifier(_) => write!(f, "InoutPortIdentifier"),
            RefNode::InputPortIdentifier(_) => write!(f, "InputPortIdentifier"),
            RefNode::InstanceIdentifier(_) => write!(f, "InstanceIdentifier"),
            RefNode::LibraryIdentifier(_) => write!(f, "LibraryIdentifier"),
            RefNode::MemberIdentifier(_) => write!(f, "MemberIdentifier"),
            RefNode::MethodIdentifier(_) => write!(f, "MethodIdentifier"),
            RefNode::ModportIdentifier(_) => write!(f, "ModportIdentifier"),
            RefNode::ModuleIdentifier(_) => write!(f, "ModuleIdentifier"),
            RefNode::NetIdentifier(_) => write!(f, "NetIdentifier"),
            RefNode::NetTypeIdentifier(_) => write!(f, "NetTypeIdentifier"),
            RefNode::OutputPortIdentifier(_) => write!(f, "OutputPortIdentifier"),
            RefNode::PackageIdentifier(_) => write!(f, "PackageIdentifier"),
            RefNode::PackageScope(_) => write!(f, "PackageScope"),
            RefNode::PackageScopePackage(_) => write!(f, "PackageScopePackage"),
            RefNode::Unit(_) => write!(f, "Unit"),
            RefNode::ParameterIdentifier(_) => write!(f, "ParameterIdentifier"),
            RefNode::PortIdentifier(_) => write!(f, "PortIdentifier"),
            RefNode::ProductionIdentifier(_) => write!(f, "ProductionIdentifier"),
            RefNode::ProgramIdentifier(_) => write!(f, "ProgramIdentifier"),
            RefNode::PropertyIdentifier(_) => write!(f, "PropertyIdentifier"),
            RefNode::PsClassIdentifier(_) => write!(f, "PsClassIdentifier"),
            RefNode::PsCovergroupIdentifier(_) => write!(f, "PsCovergroupIdentifier"),
            RefNode::PsCheckerIdentifier(_) => write!(f, "PsCheckerIdentifier"),
            RefNode::PsIdentifier(_) => write!(f, "PsIdentifier"),
            RefNode::PsOrHierarchicalArrayIdentifier(_) => write!(f, "PsOrHierarchicalArrayIdentifier"),
            RefNode::PsOrHierarchicalNetIdentifier(_) => write!(f, "PsOrHierarchicalNetIdentifier"),
            RefNode::PsOrHierarchicalNetIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalNetIdentifierPackageScope"),
            RefNode::PsOrHierarchicalNetIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalNetIdentifierHierarchical"),
            RefNode::PsOrHierarchicalPropertyIdentifier(_) => write!(f, "PsOrHierarchicalPropertyIdentifier"),
            RefNode::PsOrHierarchicalPropertyIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalPropertyIdentifierPackageScope"),
            RefNode::PsOrHierarchicalPropertyIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalPropertyIdentifierHierarchical"),
            RefNode::PsOrHierarchicalSequenceIdentifier(_) => write!(f, "PsOrHierarchicalSequenceIdentifier"),
            RefNode::PsOrHierarchicalSequenceIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalSequenceIdentifierPackageScope"),
            RefNode::PsOrHierarchicalSequenceIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalSequenceIdentifierHierarchical"),
            RefNode::PsOrHierarchicalTfIdentifier(_) => write!(f, "PsOrHierarchicalTfIdentifier"),
            RefNode::PsOrHierarchicalTfIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalTfIdentifierPackageScope"),
            RefNode::PsOrHierarchicalTfIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalTfIdentifierHierarchical"),
            RefNode::PsParameterIdentifier(_) => write!(f, "PsParameterIdentifier"),
            RefNode::PsParameterIdentifierScope(_) => write!(f, "PsParameterIdentifierScope"),
            RefNode::PsParameterIdentifierGenerate(_) => write!(f, "PsParameterIdentifierGenerate"),
            RefNode::PsTypeIdentifier(_) => write!(f, "PsTypeIdentifier"),
            RefNode::LocalOrPackageScopeOrClassScope(_) => write!(f, "LocalOrPackageScopeOrClassScope"),
            RefNode::Local(_) => write!(f, "Local"),
            RefNode::SequenceIdentifier(_) => write!(f, "SequenceIdentifier"),
            RefNode::SignalIdentifier(_) => write!(f, "SignalIdentifier"),
            RefNode::SimpleIdentifier(_) => write!(f, "SimpleIdentifier"),
            RefNode::SpecparamIdentifier(_) => write!(f, "SpecparamIdentifier"),
            RefNode::SystemTfIdentifier(_) => write!(f, "SystemTfIdentifier"),
            RefNode::TaskIdentifier(_) => write!(f, "TaskIdentifier"),
            RefNode::TfIdentifier(_) => write!(f, "TfIdentifier"),
            RefNode::TerminalIdentifier(_) => write!(f, "TerminalIdentifier"),
            RefNode::TopmoduleIdentifier(_) => write!(f, "TopmoduleIdentifier"),
            RefNode::TypeIdentifier(_) => write!(f, "TypeIdentifier"),
            RefNode::UdpIdentifier(_) => write!(f, "UdpIdentifier"),
            RefNode::VariableIdentifier(_) => write!(f, "VariableIdentifier"),
            RefNode::ImplicitClassHandleOrClassScopeOrPackageScope(_) => write!(f, "ImplicitClassHandleOrClassScopeOrPackageScope"),
            RefNode::ImplicitClassHandleOrPackageScope(_) => write!(f, "ImplicitClassHandleOrPackageScope"),
            RefNode::ImplicitClassHandleOrClassScope(_) => write!(f, "ImplicitClassHandleOrClassScope"),
            RefNode::PackageScopeOrClassScope(_) => write!(f, "PackageScopeOrClassScope"),
            RefNode::CompilerDirective(_) => write!(f, "CompilerDirective"),
            RefNode::ResetallCompilerDirective(_) => write!(f, "ResetallCompilerDirective"),
            RefNode::IncludeCompilerDirective(_) => write!(f, "IncludeCompilerDirective"),
            RefNode::IncludeCompilerDirectiveDoubleQuote(_) => write!(f, "IncludeCompilerDirectiveDoubleQuote"),
            RefNode::IncludeCompilerDirectiveAngleBracket(_) => write!(f, "IncludeCompilerDirectiveAngleBracket"),
            RefNode::IncludeCompilerDirectiveTextMacroUsage(_) => write!(f, "IncludeCompilerDirectiveTextMacroUsage"),
            RefNode::AngleBracketLiteral(_) => write!(f, "AngleBracketLiteral"),
            RefNode::TextMacroDefinition(_) => write!(f, "TextMacroDefinition"),
            RefNode::TextMacroName(_) => write!(f, "TextMacroName"),
            RefNode::ListOfFormalArguments(_) => write!(f, "ListOfFormalArguments"),
            RefNode::FormalArgument(_) => write!(f, "FormalArgument"),
            RefNode::TextMacroIdentifier(_) => write!(f, "TextMacroIdentifier"),
            RefNode::MacroText(_) => write!(f, "MacroText"),
            RefNode::DefaultText(_) => write!(f, "DefaultText"),
            RefNode::TextMacroUsage(_) => write!(f, "TextMacroUsage"),
            RefNode::ListOfActualArguments(_) => write!(f, "ListOfActualArguments"),
            RefNode::ActualArgument(_) => write!(f, "ActualArgument"),
            RefNode::UndefineCompilerDirective(_) => write!(f, "UndefineCompilerDirective"),
            RefNode::UndefineallCompilerDirective(_) => write!(f, "UndefineallCompilerDirective"),
            RefNode::ConditionalCompilerDirective(_) => write!(f, "ConditionalCompilerDirective"),
            RefNode::IfdefDirective(_) => write!(f, "IfdefDirective"),
            RefNode::IfndefDirective(_) => write!(f, "IfndefDirective"),
            RefNode::IfdefGroupOfLines(_) => write!(f, "IfdefGroupOfLines"),
            RefNode::IfndefGroupOfLines(_) => write!(f, "IfndefGroupOfLines"),
            RefNode::ElsifGroupOfLines(_) => write!(f, "ElsifGroupOfLines"),
            RefNode::ElseGroupOfLines(_) => write!(f, "ElseGroupOfLines"),
            RefNode::SourceDescription(_) => write!(f, "SourceDescription"),
            RefNode::SourceDescriptionNotDirective(_) => write!(f, "SourceDescriptionNotDirective"),
            RefNode::TimescaleCompilerDirective(_) => write!(f, "TimescaleCompilerDirective"),
            RefNode::DefaultNettypeCompilerDirective(_) => write!(f, "DefaultNettypeCompilerDirective"),
            RefNode::DefaultNettypeValue(_) => write!(f, "DefaultNettypeValue"),
            RefNode::UnconnectedDriveCompilerDirective(_) => write!(f, "UnconnectedDriveCompilerDirective"),
            RefNode::NounconnectedDriveCompilerDirective(_) => write!(f, "NounconnectedDriveCompilerDirective"),
            RefNode::CelldefineDriveCompilerDirective(_) => write!(f, "CelldefineDriveCompilerDirective"),
            RefNode::EndcelldefineDriveCompilerDirective(_) => write!(f, "EndcelldefineDriveCompilerDirective"),
            RefNode::Pragma(_) => write!(f, "Pragma"),
            RefNode::PragmaName(_) => write!(f, "PragmaName"),
            RefNode::PragmaExpression(_) => write!(f, "PragmaExpression"),
            RefNode::PragmaExpressionAssignment(_) => write!(f, "PragmaExpressionAssignment"),
            RefNode::PragmaValue(_) => write!(f, "PragmaValue"),
            RefNode::PragmaValueParen(_) => write!(f, "PragmaValueParen"),
            RefNode::PragmaKeyword(_) => write!(f, "PragmaKeyword"),
            RefNode::LineCompilerDirective(_) => write!(f, "LineCompilerDirective"),
            RefNode::PositionCompilerDirective(_) => write!(f, "PositionCompilerDirective"),
            RefNode::Level(_) => write!(f, "Level"),
            RefNode::KeywordsDirective(_) => write!(f, "KeywordsDirective"),
            RefNode::VersionSpecifier(_) => write!(f, "VersionSpecifier"),
            RefNode::EndkeywordsDirective(_) => write!(f, "EndkeywordsDirective"),
            RefNode::Comment(_) => write!(f, "Comment"),
            RefNode::AttributeInstance(_) => write!(f, "AttributeInstance"),
            RefNode::AttrSpec(_) => write!(f, "AttrSpec"),
            RefNode::SourceText(_) => write!(f, "SourceText"),
            RefNode::Description(_) => write!(f, "Description"),
            RefNode::DescriptionPackageItem(_) => write!(f, "DescriptionPackageItem"),
            RefNode::DescriptionBindDirective(_) => write!(f, "DescriptionBindDirective"),
            RefNode::ModuleNonansiHeader(_) => write!(f, "ModuleNonansiHeader"),
            RefNode::ModuleAnsiHeader(_) => write!(f, "ModuleAnsiHeader"),
            RefNode::ModuleDeclaration(_) => write!(f, "ModuleDeclaration"),
            RefNode::ModuleDeclarationNonansi(_) => write!(f, "ModuleDeclarationNonansi"),
            RefNode::ModuleDeclarationAnsi(_) => write!(f, "ModuleDeclarationAnsi"),
            RefNode::ModuleDeclarationWildcard(_) => write!(f, "ModuleDeclarationWildcard"),
            RefNode::ModuleDeclarationExternNonansi(_) => write!(f, "ModuleDeclarationExternNonansi"),
            RefNode::ModuleDeclarationExternAnsi(_) => write!(f, "ModuleDeclarationExternAnsi"),
            RefNode::ModuleKeyword(_) => write!(f, "ModuleKeyword"),
            RefNode::InterfaceDeclaration(_) => write!(f, "InterfaceDeclaration"),
            RefNode::InterfaceDeclarationNonansi(_) => write!(f, "InterfaceDeclarationNonansi"),
            RefNode::InterfaceDeclarationAnsi(_) => write!(f, "InterfaceDeclarationAnsi"),
            RefNode::InterfaceDeclarationWildcard(_) => write!(f, "InterfaceDeclarationWildcard"),
            RefNode::InterfaceDeclarationExternNonansi(_) => write!(f, "InterfaceDeclarationExternNonansi"),
            RefNode::InterfaceDeclarationExternAnsi(_) => write!(f, "InterfaceDeclarationExternAnsi"),
            RefNode::InterfaceNonansiHeader(_) => write!(f, "InterfaceNonansiHeader"),
            RefNode::InterfaceAnsiHeader(_) => write!(f, "InterfaceAnsiHeader"),
            RefNode::ProgramDeclaration(_) => write!(f, "ProgramDeclaration"),
            RefNode::ProgramDeclarationNonansi(_) => write!(f, "ProgramDeclarationNonansi"),
            RefNode::ProgramDeclarationAnsi(_) => write!(f, "ProgramDeclarationAnsi"),
            RefNode::ProgramDeclarationWildcard(_) => write!(f, "ProgramDeclarationWildcard"),
            RefNode::ProgramDeclarationExternNonansi(_) => write!(f, "ProgramDeclarationExternNonansi"),
            RefNode::ProgramDeclarationExternAnsi(_) => write!(f, "ProgramDeclarationExternAnsi"),
            RefNode::ProgramNonansiHeader(_) => write!(f, "ProgramNonansiHeader"),
            RefNode::ProgramAnsiHeader(_) => write!(f, "ProgramAnsiHeader"),
            RefNode::CheckerDeclaration(_) => write!(f, "CheckerDeclaration"),
            RefNode::ClassDeclaration(_) => write!(f, "ClassDeclaration"),
            RefNode::Virtual(_) => write!(f, "Virtual"),
            RefNode::InterfaceClassType(_) => write!(f, "InterfaceClassType"),
            RefNode::InterfaceClassDeclaration(_) => write!(f, "InterfaceClassDeclaration"),
            RefNode::InterfaceClassItem(_) => write!(f, "InterfaceClassItem"),
            RefNode::InterfaceClassItemMethod(_) => write!(f, "InterfaceClassItemMethod"),
            RefNode::InterfaceClassMethod(_) => write!(f, "InterfaceClassMethod"),
            RefNode::PackageDeclaration(_) => write!(f, "PackageDeclaration"),
            RefNode::TimeunitsDeclaration(_) => write!(f, "TimeunitsDeclaration"),
            RefNode::TimeunitsDeclarationTimeunit(_) => write!(f, "TimeunitsDeclarationTimeunit"),
            RefNode::TimeunitsDeclarationTimeprecision(_) => write!(f, "TimeunitsDeclarationTimeprecision"),
            RefNode::TimeunitsDeclarationTimeunitTimeprecision(_) => write!(f, "TimeunitsDeclarationTimeunitTimeprecision"),
            RefNode::TimeunitsDeclarationTimeprecisionTimeunit(_) => write!(f, "TimeunitsDeclarationTimeprecisionTimeunit"),
            RefNode::PackageItem(_) => write!(f, "PackageItem"),
            RefNode::PackageOrGenerateItemDeclaration(_) => write!(f, "PackageOrGenerateItemDeclaration"),
            RefNode::AnonymousProgram(_) => write!(f, "AnonymousProgram"),
            RefNode::AnonymousProgramItem(_) => write!(f, "AnonymousProgramItem"),
            RefNode::ElaborationSystemTask(_) => write!(f, "ElaborationSystemTask"),
            RefNode::ElaborationSystemTaskFatal(_) => write!(f, "ElaborationSystemTaskFatal"),
            RefNode::ElaborationSystemTaskError(_) => write!(f, "ElaborationSystemTaskError"),
            RefNode::ElaborationSystemTaskWarning(_) => write!(f, "ElaborationSystemTaskWarning"),
            RefNode::ElaborationSystemTaskInfo(_) => write!(f, "ElaborationSystemTaskInfo"),
            RefNode::FinishNumber(_) => write!(f, "FinishNumber"),
            RefNode::ModuleCommonItem(_) => write!(f, "ModuleCommonItem"),
            RefNode::ModuleItem(_) => write!(f, "ModuleItem"),
            RefNode::ModuleOrGenerateItem(_) => write!(f, "ModuleOrGenerateItem"),
            RefNode::ModuleOrGenerateItemParameter(_) => write!(f, "ModuleOrGenerateItemParameter"),
            RefNode::ModuleOrGenerateItemGate(_) => write!(f, "ModuleOrGenerateItemGate"),
            RefNode::ModuleOrGenerateItemUdp(_) => write!(f, "ModuleOrGenerateItemUdp"),
            RefNode::ModuleOrGenerateItemModule(_) => write!(f, "ModuleOrGenerateItemModule"),
            RefNode::ModuleOrGenerateItemModuleItem(_) => write!(f, "ModuleOrGenerateItemModuleItem"),
            RefNode::ModuleOrGenerateItemDeclaration(_) => write!(f, "ModuleOrGenerateItemDeclaration"),
            RefNode::ModuleOrGenerateItemDeclarationClocking(_) => write!(f, "ModuleOrGenerateItemDeclarationClocking"),
            RefNode::ModuleOrGenerateItemDeclarationDisable(_) => write!(f, "ModuleOrGenerateItemDeclarationDisable"),
            RefNode::NonPortModuleItem(_) => write!(f, "NonPortModuleItem"),
            RefNode::NonPortModuleItemSpecparam(_) => write!(f, "NonPortModuleItemSpecparam"),
            RefNode::ParameterOverride(_) => write!(f, "ParameterOverride"),
            RefNode::BindDirective(_) => write!(f, "BindDirective"),
            RefNode::BindDirectiveScope(_) => write!(f, "BindDirectiveScope"),
            RefNode::BindDirectiveInstance(_) => write!(f, "BindDirectiveInstance"),
            RefNode::BindTargetScope(_) => write!(f, "BindTargetScope"),
            RefNode::BindTargetInstance(_) => write!(f, "BindTargetInstance"),
            RefNode::BindTargetInstanceList(_) => write!(f, "BindTargetInstanceList"),
            RefNode::BindInstantiation(_) => write!(f, "BindInstantiation"),
            RefNode::ParameterPortList(_) => write!(f, "ParameterPortList"),
            RefNode::ParameterPortListAssignment(_) => write!(f, "ParameterPortListAssignment"),
            RefNode::ParameterPortListDeclaration(_) => write!(f, "ParameterPortListDeclaration"),
            RefNode::ParameterPortDeclaration(_) => write!(f, "ParameterPortDeclaration"),
            RefNode::ParameterPortDeclarationParamList(_) => write!(f, "ParameterPortDeclarationParamList"),
            RefNode::ParameterPortDeclarationTypeList(_) => write!(f, "ParameterPortDeclarationTypeList"),
            RefNode::ListOfPorts(_) => write!(f, "ListOfPorts"),
            RefNode::ListOfPortDeclarations(_) => write!(f, "ListOfPortDeclarations"),
            RefNode::PortDeclaration(_) => write!(f, "PortDeclaration"),
            RefNode::PortDeclarationInout(_) => write!(f, "PortDeclarationInout"),
            RefNode::PortDeclarationInput(_) => write!(f, "PortDeclarationInput"),
            RefNode::PortDeclarationOutput(_) => write!(f, "PortDeclarationOutput"),
            RefNode::PortDeclarationRef(_) => write!(f, "PortDeclarationRef"),
            RefNode::PortDeclarationInterface(_) => write!(f, "PortDeclarationInterface"),
            RefNode::Port(_) => write!(f, "Port"),
            RefNode::PortNonNamed(_) => write!(f, "PortNonNamed"),
            RefNode::PortNamed(_) => write!(f, "PortNamed"),
            RefNode::PortExpression(_) => write!(f, "PortExpression"),
            RefNode::PortExpressionBrace(_) => write!(f, "PortExpressionBrace"),
            RefNode::PortReference(_) => write!(f, "PortReference"),
            RefNode::PortDirection(_) => write!(f, "PortDirection"),
            RefNode::NetPortHeader(_) => write!(f, "NetPortHeader"),
            RefNode::VariablePortHeader(_) => write!(f, "VariablePortHeader"),
            RefNode::InterfacePortHeader(_) => write!(f, "InterfacePortHeader"),
            RefNode::InterfacePortHeaderIdentifier(_) => write!(f, "InterfacePortHeaderIdentifier"),
            RefNode::InterfacePortHeaderInterface(_) => write!(f, "InterfacePortHeaderInterface"),
            RefNode::NetPortHeaderOrInterfacePortHeader(_) => write!(f, "NetPortHeaderOrInterfacePortHeader"),
            RefNode::AnsiPortDeclaration(_) => write!(f, "AnsiPortDeclaration"),
            RefNode::AnsiPortDeclarationNet(_) => write!(f, "AnsiPortDeclarationNet"),
            RefNode::AnsiPortDeclarationVariable(_) => write!(f, "AnsiPortDeclarationVariable"),
            RefNode::AnsiPortDeclarationParen(_) => write!(f, "AnsiPortDeclarationParen"),
            RefNode::CheckerPortList(_) => write!(f, "CheckerPortList"),
            RefNode::CheckerPortItem(_) => write!(f, "CheckerPortItem"),
            RefNode::CheckerPortDirection(_) => write!(f, "CheckerPortDirection"),
            RefNode::CheckerOrGenerateItem(_) => write!(f, "CheckerOrGenerateItem"),
            RefNode::CheckerOrGenerateItemDeclaration(_) => write!(f, "CheckerOrGenerateItemDeclaration"),
            RefNode::CheckerOrGenerateItemDeclarationData(_) => write!(f, "CheckerOrGenerateItemDeclarationData"),
            RefNode::Rand(_) => write!(f, "Rand"),
            RefNode::CheckerOrGenerateItemDeclarationClocking(_) => write!(f, "CheckerOrGenerateItemDeclarationClocking"),
            RefNode::CheckerOrGenerateItemDeclarationDisable(_) => write!(f, "CheckerOrGenerateItemDeclarationDisable"),
            RefNode::CheckerGenerateItem(_) => write!(f, "CheckerGenerateItem"),
            RefNode::ConstraintDeclaration(_) => write!(f, "ConstraintDeclaration"),
            RefNode::Static(_) => write!(f, "Static"),
            RefNode::ConstraintBlock(_) => write!(f, "ConstraintBlock"),
            RefNode::ConstraintBlockItem(_) => write!(f, "ConstraintBlockItem"),
            RefNode::ConstraintBlockItemSolve(_) => write!(f, "ConstraintBlockItemSolve"),
            RefNode::SolveBeforeList(_) => write!(f, "SolveBeforeList"),
            RefNode::ConstraintPrimary(_) => write!(f, "ConstraintPrimary"),
            RefNode::ConstraintExpression(_) => write!(f, "ConstraintExpression"),
            RefNode::ConstraintExpressionExpression(_) => write!(f, "ConstraintExpressionExpression"),
            RefNode::Soft(_) => write!(f, "Soft"),
            RefNode::ConstraintExpressionArrow(_) => write!(f, "ConstraintExpressionArrow"),
            RefNode::ConstraintExpressionIf(_) => write!(f, "ConstraintExpressionIf"),
            RefNode::ConstraintExpressionForeach(_) => write!(f, "ConstraintExpressionForeach"),
            RefNode::ConstraintExpressionDisable(_) => write!(f, "ConstraintExpressionDisable"),
            RefNode::UniquenessConstraint(_) => write!(f, "UniquenessConstraint"),
            RefNode::ConstraintSet(_) => write!(f, "ConstraintSet"),
            RefNode::ConstraintSetBrace(_) => write!(f, "ConstraintSetBrace"),
            RefNode::DistList(_) => write!(f, "DistList"),
            RefNode::DistItem(_) => write!(f, "DistItem"),
            RefNode::DistWeight(_) => write!(f, "DistWeight"),
            RefNode::DistWeightEqual(_) => write!(f, "DistWeightEqual"),
            RefNode::DistWeightDivide(_) => write!(f, "DistWeightDivide"),
            RefNode::ConstraintPrototype(_) => write!(f, "ConstraintPrototype"),
            RefNode::ConstraintPrototypeQualifier(_) => write!(f, "ConstraintPrototypeQualifier"),
            RefNode::ExternConstraintDeclaration(_) => write!(f, "ExternConstraintDeclaration"),
            RefNode::IdentifierList(_) => write!(f, "IdentifierList"),
            RefNode::InterfaceOrGenerateItem(_) => write!(f, "InterfaceOrGenerateItem"),
            RefNode::InterfaceOrGenerateItemModule(_) => write!(f, "InterfaceOrGenerateItemModule"),
            RefNode::InterfaceOrGenerateItemExtern(_) => write!(f, "InterfaceOrGenerateItemExtern"),
            RefNode::ExternTfDeclaration(_) => write!(f, "ExternTfDeclaration"),
            RefNode::ExternTfDeclarationMethod(_) => write!(f, "ExternTfDeclarationMethod"),
            RefNode::ExternTfDeclarationTask(_) => write!(f, "ExternTfDeclarationTask"),
            RefNode::InterfaceItem(_) => write!(f, "InterfaceItem"),
            RefNode::NonPortInterfaceItem(_) => write!(f, "NonPortInterfaceItem"),
            RefNode::ProgramItem(_) => write!(f, "ProgramItem"),
            RefNode::NonPortProgramItem(_) => write!(f, "NonPortProgramItem"),
            RefNode::NonPortProgramItemAssign(_) => write!(f, "NonPortProgramItemAssign"),
            RefNode::NonPortProgramItemModule(_) => write!(f, "NonPortProgramItemModule"),
            RefNode::NonPortProgramItemInitial(_) => write!(f, "NonPortProgramItemInitial"),
            RefNode::NonPortProgramItemFinal(_) => write!(f, "NonPortProgramItemFinal"),
            RefNode::NonPortProgramItemAssertion(_) => write!(f, "NonPortProgramItemAssertion"),
            RefNode::ProgramGenerateItem(_) => write!(f, "ProgramGenerateItem"),
            RefNode::LibraryText(_) => write!(f, "LibraryText"),
            RefNode::LibraryDescription(_) => write!(f, "LibraryDescription"),
            RefNode::LibraryDeclaration(_) => write!(f, "LibraryDeclaration"),
            RefNode::IncludeStatement(_) => write!(f, "IncludeStatement"),
            RefNode::FilePathSpec(_) => write!(f, "FilePathSpec"),
            RefNode::FilePathSpecNonLiteral(_) => write!(f, "FilePathSpecNonLiteral"),
            RefNode::ConfigDeclaration(_) => write!(f, "ConfigDeclaration"),
            RefNode::DesignStatement(_) => write!(f, "DesignStatement"),
            RefNode::ConfigRuleStatement(_) => write!(f, "ConfigRuleStatement"),
            RefNode::ConfigRuleStatementDefault(_) => write!(f, "ConfigRuleStatementDefault"),
            RefNode::ConfigRuleStatementInstLib(_) => write!(f, "ConfigRuleStatementInstLib"),
            RefNode::ConfigRuleStatementInstUse(_) => write!(f, "ConfigRuleStatementInstUse"),
            RefNode::ConfigRuleStatementCellLib(_) => write!(f, "ConfigRuleStatementCellLib"),
            RefNode::ConfigRuleStatementCellUse(_) => write!(f, "ConfigRuleStatementCellUse"),
            RefNode::DefaultClause(_) => write!(f, "DefaultClause"),
            RefNode::InstClause(_) => write!(f, "InstClause"),
            RefNode::InstName(_) => write!(f, "InstName"),
            RefNode::CellClause(_) => write!(f, "CellClause"),
            RefNode::LiblistClause(_) => write!(f, "LiblistClause"),
            RefNode::UseClause(_) => write!(f, "UseClause"),
            RefNode::UseClauseCell(_) => write!(f, "UseClauseCell"),
            RefNode::UseClauseNamed(_) => write!(f, "UseClauseNamed"),
            RefNode::UseClauseCellNamed(_) => write!(f, "UseClauseCellNamed"),
            RefNode::Config(_) => write!(f, "Config"),
            RefNode::ClassItem(_) => write!(f, "ClassItem"),
            RefNode::ClassItemProperty(_) => write!(f, "ClassItemProperty"),
            RefNode::ClassItemMethod(_) => write!(f, "ClassItemMethod"),
            RefNode::ClassItemConstraint(_) => write!(f, "ClassItemConstraint"),
            RefNode::ClassItemDeclaration(_) => write!(f, "ClassItemDeclaration"),
            RefNode::ClassItemCovergroup(_) => write!(f, "ClassItemCovergroup"),
            RefNode::ClassProperty(_) => write!(f, "ClassProperty"),
            RefNode::ClassPropertyNonConst(_) => write!(f, "ClassPropertyNonConst"),
            RefNode::ClassPropertyConst(_) => write!(f, "ClassPropertyConst"),
            RefNode::ClassPropertyConstExpression(_) => write!(f, "ClassPropertyConstExpression"),
            RefNode::ClassMethod(_) => write!(f, "ClassMethod"),
            RefNode::ClassMethodTask(_) => write!(f, "ClassMethodTask"),
            RefNode::ClassMethodFunction(_) => write!(f, "ClassMethodFunction"),
            RefNode::ClassMethodPureVirtual(_) => write!(f, "ClassMethodPureVirtual"),
            RefNode::ClassMethodExternMethod(_) => write!(f, "ClassMethodExternMethod"),
            RefNode::ClassMethodConstructor(_) => write!(f, "ClassMethodConstructor"),
            RefNode::ClassMethodExternConstructor(_) => write!(f, "ClassMethodExternConstructor"),
            RefNode::ClassConstructorPrototype(_) => write!(f, "ClassConstructorPrototype"),
            RefNode::ClassConstraint(_) => write!(f, "ClassConstraint"),
            RefNode::ClassItemQualifier(_) => write!(f, "ClassItemQualifier"),
            RefNode::PropertyQualifier(_) => write!(f, "PropertyQualifier"),
            RefNode::RandomQualifier(_) => write!(f, "RandomQualifier"),
            RefNode::MethodQualifier(_) => write!(f, "MethodQualifier"),
            RefNode::MethodPrototype(_) => write!(f, "MethodPrototype"),
            RefNode::ClassConstructorDeclaration(_) => write!(f, "ClassConstructorDeclaration"),
            RefNode::New(_) => write!(f, "New"),
            RefNode::Number(_) => write!(f, "Number"),
            RefNode::IntegralNumber(_) => write!(f, "IntegralNumber"),
            RefNode::DecimalNumber(_) => write!(f, "DecimalNumber"),
            RefNode::DecimalNumberBaseUnsigned(_) => write!(f, "DecimalNumberBaseUnsigned"),
            RefNode::DecimalNumberBaseXNumber(_) => write!(f, "DecimalNumberBaseXNumber"),
            RefNode::DecimalNumberBaseZNumber(_) => write!(f, "DecimalNumberBaseZNumber"),
            RefNode::BinaryNumber(_) => write!(f, "BinaryNumber"),
            RefNode::OctalNumber(_) => write!(f, "OctalNumber"),
            RefNode::HexNumber(_) => write!(f, "HexNumber"),
            RefNode::Sign(_) => write!(f, "Sign"),
            RefNode::Size(_) => write!(f, "Size"),
            RefNode::NonZeroUnsignedNumber(_) => write!(f, "NonZeroUnsignedNumber"),
            RefNode::RealNumber(_) => write!(f, "RealNumber"),
            RefNode::RealNumberFloating(_) => write!(f, "RealNumberFloating"),
            RefNode::FixedPointNumber(_) => write!(f, "FixedPointNumber"),
            RefNode::Exp(_) => write!(f, "Exp"),
            RefNode::UnsignedNumber(_) => write!(f, "UnsignedNumber"),
            RefNode::BinaryValue(_) => write!(f, "BinaryValue"),
            RefNode::OctalValue(_) => write!(f, "OctalValue"),
            RefNode::HexValue(_) => write!(f, "HexValue"),
            RefNode::DecimalBase(_) => write!(f, "DecimalBase"),
            RefNode::BinaryBase(_) => write!(f, "BinaryBase"),
            RefNode::OctalBase(_) => write!(f, "OctalBase"),
            RefNode::HexBase(_) => write!(f, "HexBase"),
            RefNode::XNumber(_) => write!(f, "XNumber"),
            RefNode::ZNumber(_) => write!(f, "ZNumber"),
            RefNode::UnbasedUnsizedLiteral(_) => write!(f, "UnbasedUnsizedLiteral"),
            RefNode::UnaryOperator(_) => write!(f, "UnaryOperator"),
            RefNode::BinaryOperator(_) => write!(f, "BinaryOperator"),
            RefNode::IncOrDecOperator(_) => write!(f, "IncOrDecOperator"),
            RefNode::UnaryModulePathOperator(_) => write!(f, "UnaryModulePathOperator"),
            RefNode::BinaryModulePathOperator(_) => write!(f, "BinaryModulePathOperator"),
            RefNode::ConstantPrimary(_) => write!(f, "ConstantPrimary"),
            RefNode::ConstantPrimaryPsParameter(_) => write!(f, "ConstantPrimaryPsParameter"),
            RefNode::ConstantPrimarySpecparam(_) => write!(f, "ConstantPrimarySpecparam"),
            RefNode::ConstantPrimaryFormalPort(_) => write!(f, "ConstantPrimaryFormalPort"),
            RefNode::ConstantPrimaryEnum(_) => write!(f, "ConstantPrimaryEnum"),
            RefNode::ConstantPrimaryConcatenation(_) => write!(f, "ConstantPrimaryConcatenation"),
            RefNode::ConstantPrimaryMultipleConcatenation(_) => write!(f, "ConstantPrimaryMultipleConcatenation"),
            RefNode::ConstantPrimaryMintypmaxExpression(_) => write!(f, "ConstantPrimaryMintypmaxExpression"),
            RefNode::ModulePathPrimary(_) => write!(f, "ModulePathPrimary"),
            RefNode::ModulePathPrimaryMintypmax(_) => write!(f, "ModulePathPrimaryMintypmax"),
            RefNode::Primary(_) => write!(f, "Primary"),
            RefNode::PrimaryHierarchical(_) => write!(f, "PrimaryHierarchical"),
            RefNode::PrimaryConcatenation(_) => write!(f, "PrimaryConcatenation"),
            RefNode::PrimaryMultipleConcatenation(_) => write!(f, "PrimaryMultipleConcatenation"),
            RefNode::PrimaryMintypmaxExpression(_) => write!(f, "PrimaryMintypmaxExpression"),
            RefNode::ClassQualifierOrPackageScope(_) => write!(f, "ClassQualifierOrPackageScope"),
            RefNode::ClassQualifier(_) => write!(f, "ClassQualifier"),
            RefNode::RangeExpression(_) => write!(f, "RangeExpression"),
            RefNode::PrimaryLiteral(_) => write!(f, "PrimaryLiteral"),
            RefNode::TimeLiteral(_) => write!(f, "TimeLiteral"),
            RefNode::TimeLiteralUnsigned(_) => write!(f, "TimeLiteralUnsigned"),
            RefNode::TimeLiteralFixedPoint(_) => write!(f, "TimeLiteralFixedPoint"),
            RefNode::TimeUnit(_) => write!(f, "TimeUnit"),
            RefNode::ImplicitClassHandle(_) => write!(f, "ImplicitClassHandle"),
            RefNode::BitSelect(_) => write!(f, "BitSelect"),
            RefNode::Select(_) => write!(f, "Select"),
            RefNode::NonrangeSelect(_) => write!(f, "NonrangeSelect"),
            RefNode::ConstantBitSelect(_) => write!(f, "ConstantBitSelect"),
            RefNode::ConstantSelect(_) => write!(f, "ConstantSelect"),
            RefNode::ConstantCast(_) => write!(f, "ConstantCast"),
            RefNode::ConstantLetExpression(_) => write!(f, "ConstantLetExpression"),
            RefNode::Cast(_) => write!(f, "Cast"),
            RefNode::Concatenation(_) => write!(f, "Concatenation"),
            RefNode::ConstantConcatenation(_) => write!(f, "ConstantConcatenation"),
            RefNode::ConstantMultipleConcatenation(_) => write!(f, "ConstantMultipleConcatenation"),
            RefNode::ModulePathConcatenation(_) => write!(f, "ModulePathConcatenation"),
            RefNode::ModulePathMultipleConcatenation(_) => write!(f, "ModulePathMultipleConcatenation"),
            RefNode::MultipleConcatenation(_) => write!(f, "MultipleConcatenation"),
            RefNode::StreamingConcatenation(_) => write!(f, "StreamingConcatenation"),
            RefNode::StreamOperator(_) => write!(f, "StreamOperator"),
            RefNode::SliceSize(_) => write!(f, "SliceSize"),
            RefNode::StreamConcatenation(_) => write!(f, "StreamConcatenation"),
            RefNode::StreamExpression(_) => write!(f, "StreamExpression"),
            RefNode::ArrayRangeExpression(_) => write!(f, "ArrayRangeExpression"),
            RefNode::ArrayRangeExpressionColon(_) => write!(f, "ArrayRangeExpressionColon"),
            RefNode::ArrayRangeExpressionPlusColon(_) => write!(f, "ArrayRangeExpressionPlusColon"),
            RefNode::ArrayRangeExpressionMinusColon(_) => write!(f, "ArrayRangeExpressionMinusColon"),
            RefNode::EmptyUnpackedArrayConcatenation(_) => write!(f, "EmptyUnpackedArrayConcatenation"),
            RefNode::IncOrDecExpression(_) => write!(f, "IncOrDecExpression"),
            RefNode::IncOrDecExpressionPrefix(_) => write!(f, "IncOrDecExpressionPrefix"),
            RefNode::IncOrDecExpressionSuffix(_) => write!(f, "IncOrDecExpressionSuffix"),
            RefNode::ConditionalExpression(_) => write!(f, "ConditionalExpression"),
            RefNode::ConstantExpression(_) => write!(f, "ConstantExpression"),
            RefNode::ConstantExpressionUnary(_) => write!(f, "ConstantExpressionUnary"),
            RefNode::ConstantExpressionBinary(_) => write!(f, "ConstantExpressionBinary"),
            RefNode::ConstantExpressionTernary(_) => write!(f, "ConstantExpressionTernary"),
            RefNode::ConstantMintypmaxExpression(_) => write!(f, "ConstantMintypmaxExpression"),
            RefNode::ConstantMintypmaxExpressionTernary(_) => write!(f, "ConstantMintypmaxExpressionTernary"),
            RefNode::ConstantParamExpression(_) => write!(f, "ConstantParamExpression"),
            RefNode::ParamExpression(_) => write!(f, "ParamExpression"),
            RefNode::ConstantRangeExpression(_) => write!(f, "ConstantRangeExpression"),
            RefNode::ConstantPartSelectRange(_) => write!(f, "ConstantPartSelectRange"),
            RefNode::ConstantRange(_) => write!(f, "ConstantRange"),
            RefNode::ConstantIndexedRange(_) => write!(f, "ConstantIndexedRange"),
            RefNode::Expression(_) => write!(f, "Expression"),
            RefNode::ExpressionUnary(_) => write!(f, "ExpressionUnary"),
            RefNode::ExpressionOperatorAssignment(_) => write!(f, "ExpressionOperatorAssignment"),
            RefNode::ExpressionBinary(_) => write!(f, "ExpressionBinary"),
            RefNode::TaggedUnionExpression(_) => write!(f, "TaggedUnionExpression"),
            RefNode::InsideExpression(_) => write!(f, "InsideExpression"),
            RefNode::ValueRange(_) => write!(f, "ValueRange"),
            RefNode::ValueRangeBinary(_) => write!(f, "ValueRangeBinary"),
            RefNode::MintypmaxExpression(_) => write!(f, "MintypmaxExpression"),
            RefNode::MintypmaxExpressionTernary(_) => write!(f, "MintypmaxExpressionTernary"),
            RefNode::ModulePathConditionalExpression(_) => write!(f, "ModulePathConditionalExpression"),
            RefNode::ModulePathExpression(_) => write!(f, "ModulePathExpression"),
            RefNode::ModulePathExpressionUnary(_) => write!(f, "ModulePathExpressionUnary"),
            RefNode::ModulePathExpressionBinary(_) => write!(f, "ModulePathExpressionBinary"),
            RefNode::ModulePathMintypmaxExpression(_) => write!(f, "ModulePathMintypmaxExpression"),
            RefNode::ModulePathMintypmaxExpressionTernary(_) => write!(f, "ModulePathMintypmaxExpressionTernary"),
            RefNode::PartSelectRange(_) => write!(f, "PartSelectRange"),
            RefNode::IndexedRange(_) => write!(f, "IndexedRange"),
            RefNode::GenvarExpression(_) => write!(f, "GenvarExpression"),
            RefNode::ConstantFunctionCall(_) => write!(f, "ConstantFunctionCall"),
            RefNode::TfCall(_) => write!(f, "TfCall"),
            RefNode::SystemTfCall(_) => write!(f, "SystemTfCall"),
            RefNode::SystemTfCallArgOptional(_) => write!(f, "SystemTfCallArgOptional"),
            RefNode::SystemTfCallArgDataType(_) => write!(f, "SystemTfCallArgDataType"),
            RefNode::SystemTfCallArgExpression(_) => write!(f, "SystemTfCallArgExpression"),
            RefNode::SubroutineCall(_) => write!(f, "SubroutineCall"),
            RefNode::SubroutineCallRandomize(_) => write!(f, "SubroutineCallRandomize"),
            RefNode::FunctionSubroutineCall(_) => write!(f, "FunctionSubroutineCall"),
            RefNode::ListOfArguments(_) => write!(f, "ListOfArguments"),
            RefNode::ListOfArgumentsOrdered(_) => write!(f, "ListOfArgumentsOrdered"),
            RefNode::ListOfArgumentsNamed(_) => write!(f, "ListOfArgumentsNamed"),
            RefNode::MethodCall(_) => write!(f, "MethodCall"),
            RefNode::MethodCallBody(_) => write!(f, "MethodCallBody"),
            RefNode::MethodCallBodyUser(_) => write!(f, "MethodCallBodyUser"),
            RefNode::BuiltInMethodCall(_) => write!(f, "BuiltInMethodCall"),
            RefNode::ArrayManipulationCall(_) => write!(f, "ArrayManipulationCall"),
            RefNode::RandomizeCall(_) => write!(f, "RandomizeCall"),
            RefNode::VariableIdentifierListOrNull(_) => write!(f, "VariableIdentifierListOrNull"),
            RefNode::MethodCallRoot(_) => write!(f, "MethodCallRoot"),
            RefNode::ArrayMethodName(_) => write!(f, "ArrayMethodName"),
            RefNode::StringLiteral(_) => write!(f, "StringLiteral"),
            RefNode::NetLvalue(_) => write!(f, "NetLvalue"),
            RefNode::NetLvalueIdentifier(_) => write!(f, "NetLvalueIdentifier"),
            RefNode::NetLvalueLvalue(_) => write!(f, "NetLvalueLvalue"),
            RefNode::NetLvaluePattern(_) => write!(f, "NetLvaluePattern"),
            RefNode::VariableLvalue(_) => write!(f, "VariableLvalue"),
            RefNode::VariableLvalueIdentifier(_) => write!(f, "VariableLvalueIdentifier"),
            RefNode::VariableLvalueLvalue(_) => write!(f, "VariableLvalueLvalue"),
            RefNode::VariableLvaluePattern(_) => write!(f, "VariableLvaluePattern"),
            RefNode::NonrangeVariableLvalue(_) => write!(f, "NonrangeVariableLvalue"),
            RefNode::PreprocessorText(_) => write!(f, "PreprocessorText"),
            RefNode::CmosSwitchtype(_) => write!(f, "CmosSwitchtype"),
            RefNode::EnableGatetype(_) => write!(f, "EnableGatetype"),
            RefNode::MosSwitchtype(_) => write!(f, "MosSwitchtype"),
            RefNode::NInputGatetype(_) => write!(f, "NInputGatetype"),
            RefNode::NOutputGatetype(_) => write!(f, "NOutputGatetype"),
            RefNode::PassEnSwitchtype(_) => write!(f, "PassEnSwitchtype"),
            RefNode::PassSwitchtype(_) => write!(f, "PassSwitchtype"),
            RefNode::PulldownStrength(_) => write!(f, "PulldownStrength"),
            RefNode::PulldownStrength01(_) => write!(f, "PulldownStrength01"),
            RefNode::PulldownStrength10(_) => write!(f, "PulldownStrength10"),
            RefNode::PulldownStrength0(_) => write!(f, "PulldownStrength0"),
            RefNode::PullupStrength(_) => write!(f, "PullupStrength"),
            RefNode::PullupStrength01(_) => write!(f, "PullupStrength01"),
            RefNode::PullupStrength10(_) => write!(f, "PullupStrength10"),
            RefNode::PullupStrength1(_) => write!(f, "PullupStrength1"),
            RefNode::EnableTerminal(_) => write!(f, "EnableTerminal"),
            RefNode::InoutTerminal(_) => write!(f, "InoutTerminal"),
            RefNode::InputTerminal(_) => write!(f, "InputTerminal"),
            RefNode::NcontrolTerminal(_) => write!(f, "NcontrolTerminal"),
            RefNode::OutputTerminal(_) => write!(f, "OutputTerminal"),
            RefNode::PcontrolTerminal(_) => write!(f, "PcontrolTerminal"),
            RefNode::GateInstantiation(_) => write!(f, "GateInstantiation"),
            RefNode::GateInstantiationCmos(_) => write!(f, "GateInstantiationCmos"),
            RefNode::GateInstantiationEnable(_) => write!(f, "GateInstantiationEnable"),
            RefNode::GateInstantiationMos(_) => write!(f, "GateInstantiationMos"),
            RefNode::GateInstantiationNInput(_) => write!(f, "GateInstantiationNInput"),
            RefNode::GateInstantiationNOutput(_) => write!(f, "GateInstantiationNOutput"),
            RefNode::GateInstantiationPassEn(_) => write!(f, "GateInstantiationPassEn"),
            RefNode::GateInstantiationPass(_) => write!(f, "GateInstantiationPass"),
            RefNode::GateInstantiationPulldown(_) => write!(f, "GateInstantiationPulldown"),
            RefNode::GateInstantiationPullup(_) => write!(f, "GateInstantiationPullup"),
            RefNode::CmosSwitchInstance(_) => write!(f, "CmosSwitchInstance"),
            RefNode::EnableGateInstance(_) => write!(f, "EnableGateInstance"),
            RefNode::MosSwitchInstance(_) => write!(f, "MosSwitchInstance"),
            RefNode::NInputGateInstance(_) => write!(f, "NInputGateInstance"),
            RefNode::NOutputGateInstance(_) => write!(f, "NOutputGateInstance"),
            RefNode::PassSwitchInstance(_) => write!(f, "PassSwitchInstance"),
            RefNode::PassEnableSwitchInstance(_) => write!(f, "PassEnableSwitchInstance"),
            RefNode::PullGateInstance(_) => write!(f, "PullGateInstance"),
            RefNode::ConcurrentAssertionItem(_) => write!(f, "ConcurrentAssertionItem"),
            RefNode::ConcurrentAssertionItemStatement(_) => write!(f, "ConcurrentAssertionItemStatement"),
            RefNode::ConcurrentAssertionStatement(_) => write!(f, "ConcurrentAssertionStatement"),
            RefNode::AssertPropertyStatement(_) => write!(f, "AssertPropertyStatement"),
            RefNode::AssumePropertyStatement(_) => write!(f, "AssumePropertyStatement"),
            RefNode::CoverPropertyStatement(_) => write!(f, "CoverPropertyStatement"),
            RefNode::ExpectPropertyStatement(_) => write!(f, "ExpectPropertyStatement"),
            RefNode::CoverSequenceStatement(_) => write!(f, "CoverSequenceStatement"),
            RefNode::RestrictPropertyStatement(_) => write!(f, "RestrictPropertyStatement"),
            RefNode::PropertyInstance(_) => write!(f, "PropertyInstance"),
            RefNode::PropertyListOfArguments(_) => write!(f, "PropertyListOfArguments"),
            RefNode::PropertyListOfArgumentsOrdered(_) => write!(f, "PropertyListOfArgumentsOrdered"),
            RefNode::PropertyListOfArgumentsNamed(_) => write!(f, "PropertyListOfArgumentsNamed"),
            RefNode::PropertyActualArg(_) => write!(f, "PropertyActualArg"),
            RefNode::AssertionItemDeclaration(_) => write!(f, "AssertionItemDeclaration"),
            RefNode::PropertyDeclaration(_) => write!(f, "PropertyDeclaration"),
            RefNode::PropertyPortList(_) => write!(f, "PropertyPortList"),
            RefNode::PropertyPortItem(_) => write!(f, "PropertyPortItem"),
            RefNode::PropertyLvarPortDirection(_) => write!(f, "PropertyLvarPortDirection"),
            RefNode::PropertyFormalType(_) => write!(f, "PropertyFormalType"),
            RefNode::PropertySpec(_) => write!(f, "PropertySpec"),
            RefNode::PropertyExpr(_) => write!(f, "PropertyExpr"),
            RefNode::PropertyExprStrong(_) => write!(f, "PropertyExprStrong"),
            RefNode::PropertyExprWeak(_) => write!(f, "PropertyExprWeak"),
            RefNode::PropertyExprParen(_) => write!(f, "PropertyExprParen"),
            RefNode::PropertyExprNot(_) => write!(f, "PropertyExprNot"),
            RefNode::PropertyExprBinaryProperty(_) => write!(f, "PropertyExprBinaryProperty"),
            RefNode::PropertyExprBinarySequence(_) => write!(f, "PropertyExprBinarySequence"),
            RefNode::PropertyExprIf(_) => write!(f, "PropertyExprIf"),
            RefNode::PropertyExprCase(_) => write!(f, "PropertyExprCase"),
            RefNode::PropertyExprNexttime(_) => write!(f, "PropertyExprNexttime"),
            RefNode::PropertyExprSNexttime(_) => write!(f, "PropertyExprSNexttime"),
            RefNode::PropertyExprAlways(_) => write!(f, "PropertyExprAlways"),
            RefNode::PropertyExprSAlways(_) => write!(f, "PropertyExprSAlways"),
            RefNode::PropertyExprEventually(_) => write!(f, "PropertyExprEventually"),
            RefNode::PropertyExprSEventually(_) => write!(f, "PropertyExprSEventually"),
            RefNode::PropertyExprAcceptOn(_) => write!(f, "PropertyExprAcceptOn"),
            RefNode::PropertyExprRejectOn(_) => write!(f, "PropertyExprRejectOn"),
            RefNode::PropertyExprSyncAcceptOn(_) => write!(f, "PropertyExprSyncAcceptOn"),
            RefNode::PropertyExprSyncRejectOn(_) => write!(f, "PropertyExprSyncRejectOn"),
            RefNode::PropertyExprClockingEvent(_) => write!(f, "PropertyExprClockingEvent"),
            RefNode::PropertyCaseItem(_) => write!(f, "PropertyCaseItem"),
            RefNode::PropertyCaseItemNondefault(_) => write!(f, "PropertyCaseItemNondefault"),
            RefNode::PropertyCaseItemDefault(_) => write!(f, "PropertyCaseItemDefault"),
            RefNode::SequenceDeclaration(_) => write!(f, "SequenceDeclaration"),
            RefNode::SequencePortList(_) => write!(f, "SequencePortList"),
            RefNode::SequencePortItem(_) => write!(f, "SequencePortItem"),
            RefNode::SequenceLvarPortDirection(_) => write!(f, "SequenceLvarPortDirection"),
            RefNode::SequenceFormalType(_) => write!(f, "SequenceFormalType"),
            RefNode::SequenceExpr(_) => write!(f, "SequenceExpr"),
            RefNode::SequenceExprCycleDelayExpr(_) => write!(f, "SequenceExprCycleDelayExpr"),
            RefNode::SequenceExprExprCycleDelayExpr(_) => write!(f, "SequenceExprExprCycleDelayExpr"),
            RefNode::SequenceExprExpression(_) => write!(f, "SequenceExprExpression"),
            RefNode::SequenceExprInstance(_) => write!(f, "SequenceExprInstance"),
            RefNode::SequenceExprParen(_) => write!(f, "SequenceExprParen"),
            RefNode::SequenceExprBinary(_) => write!(f, "SequenceExprBinary"),
            RefNode::SequenceExprFirstMatch(_) => write!(f, "SequenceExprFirstMatch"),
            RefNode::SequenceExprThroughout(_) => write!(f, "SequenceExprThroughout"),
            RefNode::SequenceExprClockingEvent(_) => write!(f, "SequenceExprClockingEvent"),
            RefNode::CycleDelayRange(_) => write!(f, "CycleDelayRange"),
            RefNode::CycleDelayRangePrimary(_) => write!(f, "CycleDelayRangePrimary"),
            RefNode::CycleDelayRangeExpression(_) => write!(f, "CycleDelayRangeExpression"),
            RefNode::CycleDelayRangeAsterisk(_) => write!(f, "CycleDelayRangeAsterisk"),
            RefNode::CycleDelayRangePlus(_) => write!(f, "CycleDelayRangePlus"),
            RefNode::SequenceMethodCall(_) => write!(f, "SequenceMethodCall"),
            RefNode::SequenceMatchItem(_) => write!(f, "SequenceMatchItem"),
            RefNode::SequenceInstance(_) => write!(f, "SequenceInstance"),
            RefNode::SequenceListOfArguments(_) => write!(f, "SequenceListOfArguments"),
            RefNode::SequenceListOfArgumentsOrdered(_) => write!(f, "SequenceListOfArgumentsOrdered"),
            RefNode::SequenceListOfArgumentsNamed(_) => write!(f, "SequenceListOfArgumentsNamed"),
            RefNode::SequenceActualArg(_) => write!(f, "SequenceActualArg"),
            RefNode::BooleanAbbrev(_) => write!(f, "BooleanAbbrev"),
            RefNode::SequenceAbbrev(_) => write!(f, "SequenceAbbrev"),
            RefNode::ConsecutiveRepetition(_) => write!(f, "ConsecutiveRepetition"),
            RefNode::ConsecutiveRepetitionExpression(_) => write!(f, "ConsecutiveRepetitionExpression"),
            RefNode::ConsecutiveRepetitionAsterisk(_) => write!(f, "ConsecutiveRepetitionAsterisk"),
            RefNode::ConsecutiveRepetitionPlus(_) => write!(f, "ConsecutiveRepetitionPlus"),
            RefNode::NonConsecutiveRepetition(_) => write!(f, "NonConsecutiveRepetition"),
            RefNode::GotoRepetition(_) => write!(f, "GotoRepetition"),
            RefNode::ConstOrRangeExpression(_) => write!(f, "ConstOrRangeExpression"),
            RefNode::CycleDelayConstRangeExpression(_) => write!(f, "CycleDelayConstRangeExpression"),
            RefNode::CycleDelayConstRangeExpressionBinary(_) => write!(f, "CycleDelayConstRangeExpressionBinary"),
            RefNode::CycleDelayConstRangeExpressionDollar(_) => write!(f, "CycleDelayConstRangeExpressionDollar"),
            RefNode::ExpressionOrDist(_) => write!(f, "ExpressionOrDist"),
            RefNode::AssertionVariableDeclaration(_) => write!(f, "AssertionVariableDeclaration"),
            RefNode::TaskDeclaration(_) => write!(f, "TaskDeclaration"),
            RefNode::TaskBodyDeclaration(_) => write!(f, "TaskBodyDeclaration"),
            RefNode::TaskBodyDeclarationWithoutPort(_) => write!(f, "TaskBodyDeclarationWithoutPort"),
            RefNode::TaskBodyDeclarationWithPort(_) => write!(f, "TaskBodyDeclarationWithPort"),
            RefNode::TfItemDeclaration(_) => write!(f, "TfItemDeclaration"),
            RefNode::TfPortList(_) => write!(f, "TfPortList"),
            RefNode::TfPortItem(_) => write!(f, "TfPortItem"),
            RefNode::TfPortDirection(_) => write!(f, "TfPortDirection"),
            RefNode::TfPortDeclaration(_) => write!(f, "TfPortDeclaration"),
            RefNode::TaskPrototype(_) => write!(f, "TaskPrototype"),
            RefNode::DefparamAssignment(_) => write!(f, "DefparamAssignment"),
            RefNode::NetDeclAssignment(_) => write!(f, "NetDeclAssignment"),
            RefNode::ParamAssignment(_) => write!(f, "ParamAssignment"),
            RefNode::SpecparamAssignment(_) => write!(f, "SpecparamAssignment"),
            RefNode::SpecparamAssignmentMintypmax(_) => write!(f, "SpecparamAssignmentMintypmax"),
            RefNode::TypeAssignment(_) => write!(f, "TypeAssignment"),
            RefNode::PulseControlSpecparam(_) => write!(f, "PulseControlSpecparam"),
            RefNode::PulseControlSpecparamWithoutDescriptor(_) => write!(f, "PulseControlSpecparamWithoutDescriptor"),
            RefNode::PulseControlSpecparamWithDescriptor(_) => write!(f, "PulseControlSpecparamWithDescriptor"),
            RefNode::ErrorLimitValue(_) => write!(f, "ErrorLimitValue"),
            RefNode::RejectLimitValue(_) => write!(f, "RejectLimitValue"),
            RefNode::LimitValue(_) => write!(f, "LimitValue"),
            RefNode::VariableDeclAssignment(_) => write!(f, "VariableDeclAssignment"),
            RefNode::VariableDeclAssignmentVariable(_) => write!(f, "VariableDeclAssignmentVariable"),
            RefNode::VariableDeclAssignmentDynamicArray(_) => write!(f, "VariableDeclAssignmentDynamicArray"),
            RefNode::VariableDeclAssignmentClass(_) => write!(f, "VariableDeclAssignmentClass"),
            RefNode::ClassNew(_) => write!(f, "ClassNew"),
            RefNode::ClassNewArgument(_) => write!(f, "ClassNewArgument"),
            RefNode::ClassNewExpression(_) => write!(f, "ClassNewExpression"),
            RefNode::DynamicArrayNew(_) => write!(f, "DynamicArrayNew"),
            RefNode::ListOfDefparamAssignments(_) => write!(f, "ListOfDefparamAssignments"),
            RefNode::ListOfGenvarIdentifiers(_) => write!(f, "ListOfGenvarIdentifiers"),
            RefNode::ListOfInterfaceIdentifiers(_) => write!(f, "ListOfInterfaceIdentifiers"),
            RefNode::ListOfNetDeclAssignments(_) => write!(f, "ListOfNetDeclAssignments"),
            RefNode::ListOfParamAssignments(_) => write!(f, "ListOfParamAssignments"),
            RefNode::ListOfPortIdentifiers(_) => write!(f, "ListOfPortIdentifiers"),
            RefNode::ListOfUdpPortIdentifiers(_) => write!(f, "ListOfUdpPortIdentifiers"),
            RefNode::ListOfSpecparamAssignments(_) => write!(f, "ListOfSpecparamAssignments"),
            RefNode::ListOfTfVariableIdentifiers(_) => write!(f, "ListOfTfVariableIdentifiers"),
            RefNode::ListOfTypeAssignments(_) => write!(f, "ListOfTypeAssignments"),
            RefNode::ListOfVariableDeclAssignments(_) => write!(f, "ListOfVariableDeclAssignments"),
            RefNode::ListOfVariableIdentifiers(_) => write!(f, "ListOfVariableIdentifiers"),
            RefNode::ListOfVariablePortIdentifiers(_) => write!(f, "ListOfVariablePortIdentifiers"),
            RefNode::DataDeclaration(_) => write!(f, "DataDeclaration"),
            RefNode::DataDeclarationVariable(_) => write!(f, "DataDeclarationVariable"),
            RefNode::Const(_) => write!(f, "Const"),
            RefNode::PackageImportDeclaration(_) => write!(f, "PackageImportDeclaration"),
            RefNode::PackageImportItem(_) => write!(f, "PackageImportItem"),
            RefNode::PackageImportItemIdentifier(_) => write!(f, "PackageImportItemIdentifier"),
            RefNode::PackageImportItemAsterisk(_) => write!(f, "PackageImportItemAsterisk"),
            RefNode::PackageExportDeclaration(_) => write!(f, "PackageExportDeclaration"),
            RefNode::PackageExportDeclarationAsterisk(_) => write!(f, "PackageExportDeclarationAsterisk"),
            RefNode::PackageExportDeclarationItem(_) => write!(f, "PackageExportDeclarationItem"),
            RefNode::GenvarDeclaration(_) => write!(f, "GenvarDeclaration"),
            RefNode::NetDeclaration(_) => write!(f, "NetDeclaration"),
            RefNode::NetDeclarationNetType(_) => write!(f, "NetDeclarationNetType"),
            RefNode::Strength(_) => write!(f, "Strength"),
            RefNode::VectorScalar(_) => write!(f, "VectorScalar"),
            RefNode::NetDeclarationNetTypeIdentifier(_) => write!(f, "NetDeclarationNetTypeIdentifier"),
            RefNode::NetDeclarationInterconnect(_) => write!(f, "NetDeclarationInterconnect"),
            RefNode::TypeDeclaration(_) => write!(f, "TypeDeclaration"),
            RefNode::TypeDeclarationDataType(_) => write!(f, "TypeDeclarationDataType"),
            RefNode::TypeDeclarationInterface(_) => write!(f, "TypeDeclarationInterface"),
            RefNode::TypeDeclarationReserved(_) => write!(f, "TypeDeclarationReserved"),
            RefNode::TypeDeclarationKeyword(_) => write!(f, "TypeDeclarationKeyword"),
            RefNode::NetTypeDeclaration(_) => write!(f, "NetTypeDeclaration"),
            RefNode::NetTypeDeclarationDataType(_) => write!(f, "NetTypeDeclarationDataType"),
            RefNode::NetTypeDeclarationNetType(_) => write!(f, "NetTypeDeclarationNetType"),
            RefNode::Lifetime(_) => write!(f, "Lifetime"),
            RefNode::DriveStrength(_) => write!(f, "DriveStrength"),
            RefNode::DriveStrength01(_) => write!(f, "DriveStrength01"),
            RefNode::DriveStrength10(_) => write!(f, "DriveStrength10"),
            RefNode::DriveStrength0z(_) => write!(f, "DriveStrength0z"),
            RefNode::DriveStrength1z(_) => write!(f, "DriveStrength1z"),
            RefNode::DriveStrengthz1(_) => write!(f, "DriveStrengthz1"),
            RefNode::DriveStrengthz0(_) => write!(f, "DriveStrengthz0"),
            RefNode::Strength0(_) => write!(f, "Strength0"),
            RefNode::Strength1(_) => write!(f, "Strength1"),
            RefNode::ChargeStrength(_) => write!(f, "ChargeStrength"),
            RefNode::ChargeStrengthSmall(_) => write!(f, "ChargeStrengthSmall"),
            RefNode::ChargeStrengthMedium(_) => write!(f, "ChargeStrengthMedium"),
            RefNode::ChargeStrengthLarge(_) => write!(f, "ChargeStrengthLarge"),
            RefNode::LetDeclaration(_) => write!(f, "LetDeclaration"),
            RefNode::LetIdentifier(_) => write!(f, "LetIdentifier"),
            RefNode::LetPortList(_) => write!(f, "LetPortList"),
            RefNode::LetPortItem(_) => write!(f, "LetPortItem"),
            RefNode::LetFormalType(_) => write!(f, "LetFormalType"),
            RefNode::LetExpression(_) => write!(f, "LetExpression"),
            RefNode::LetListOfArguments(_) => write!(f, "LetListOfArguments"),
            RefNode::LetListOfArgumentsOrdered(_) => write!(f, "LetListOfArgumentsOrdered"),
            RefNode::LetListOfArgumentsNamed(_) => write!(f, "LetListOfArgumentsNamed"),
            RefNode::LetActualArg(_) => write!(f, "LetActualArg"),
            RefNode::InoutDeclaration(_) => write!(f, "InoutDeclaration"),
            RefNode::InputDeclaration(_) => write!(f, "InputDeclaration"),
            RefNode::InputDeclarationNet(_) => write!(f, "InputDeclarationNet"),
            RefNode::InputDeclarationVariable(_) => write!(f, "InputDeclarationVariable"),
            RefNode::OutputDeclaration(_) => write!(f, "OutputDeclaration"),
            RefNode::OutputDeclarationNet(_) => write!(f, "OutputDeclarationNet"),
            RefNode::OutputDeclarationVariable(_) => write!(f, "OutputDeclarationVariable"),
            RefNode::InterfacePortDeclaration(_) => write!(f, "InterfacePortDeclaration"),
            RefNode::RefDeclaration(_) => write!(f, "RefDeclaration"),
            RefNode::UnpackedDimension(_) => write!(f, "UnpackedDimension"),
            RefNode::UnpackedDimensionRange(_) => write!(f, "UnpackedDimensionRange"),
            RefNode::UnpackedDimensionExpression(_) => write!(f, "UnpackedDimensionExpression"),
            RefNode::PackedDimension(_) => write!(f, "PackedDimension"),
            RefNode::PackedDimensionRange(_) => write!(f, "PackedDimensionRange"),
            RefNode::AssociativeDimension(_) => write!(f, "AssociativeDimension"),
            RefNode::AssociativeDimensionDataType(_) => write!(f, "AssociativeDimensionDataType"),
            RefNode::AssociativeDimensionAsterisk(_) => write!(f, "AssociativeDimensionAsterisk"),
            RefNode::VariableDimension(_) => write!(f, "VariableDimension"),
            RefNode::QueueDimension(_) => write!(f, "QueueDimension"),
            RefNode::UnsizedDimension(_) => write!(f, "UnsizedDimension"),
            RefNode::LocalParameterDeclaration(_) => write!(f, "LocalParameterDeclaration"),
            RefNode::LocalParameterDeclarationParam(_) => write!(f, "LocalParameterDeclarationParam"),
            RefNode::LocalParameterDeclarationType(_) => write!(f, "LocalParameterDeclarationType"),
            RefNode::ParameterDeclaration(_) => write!(f, "ParameterDeclaration"),
            RefNode::ParameterDeclarationParam(_) => write!(f, "ParameterDeclarationParam"),
            RefNode::ParameterDeclarationType(_) => write!(f, "ParameterDeclarationType"),
            RefNode::SpecparamDeclaration(_) => write!(f, "SpecparamDeclaration"),
            RefNode::CovergroupDeclaration(_) => write!(f, "CovergroupDeclaration"),
            RefNode::CoverageSpecOrOption(_) => write!(f, "CoverageSpecOrOption"),
            RefNode::CoverageSpecOrOptionSpec(_) => write!(f, "CoverageSpecOrOptionSpec"),
            RefNode::CoverageSpecOrOptionOption(_) => write!(f, "CoverageSpecOrOptionOption"),
            RefNode::CoverageOption(_) => write!(f, "CoverageOption"),
            RefNode::CoverageOptionOption(_) => write!(f, "CoverageOptionOption"),
            RefNode::CoverageOptionTypeOption(_) => write!(f, "CoverageOptionTypeOption"),
            RefNode::CoverageSpec(_) => write!(f, "CoverageSpec"),
            RefNode::CoverageEvent(_) => write!(f, "CoverageEvent"),
            RefNode::CoverageEventSample(_) => write!(f, "CoverageEventSample"),
            RefNode::CoverageEventAt(_) => write!(f, "CoverageEventAt"),
            RefNode::BlockEventExpression(_) => write!(f, "BlockEventExpression"),
            RefNode::BlockEventExpressionOr(_) => write!(f, "BlockEventExpressionOr"),
            RefNode::BlockEventExpressionBegin(_) => write!(f, "BlockEventExpressionBegin"),
            RefNode::BlockEventExpressionEnd(_) => write!(f, "BlockEventExpressionEnd"),
            RefNode::HierarchicalBtfIdentifier(_) => write!(f, "HierarchicalBtfIdentifier"),
            RefNode::HierarchicalBtfIdentifierMethod(_) => write!(f, "HierarchicalBtfIdentifierMethod"),
            RefNode::HierarchicalIdentifierOrClassScope(_) => write!(f, "HierarchicalIdentifierOrClassScope"),
            RefNode::CoverPoint(_) => write!(f, "CoverPoint"),
            RefNode::BinsOrEmpty(_) => write!(f, "BinsOrEmpty"),
            RefNode::BinsOrEmptyNonEmpty(_) => write!(f, "BinsOrEmptyNonEmpty"),
            RefNode::BinsOrOptions(_) => write!(f, "BinsOrOptions"),
            RefNode::BinsOrOptionsCovergroup(_) => write!(f, "BinsOrOptionsCovergroup"),
            RefNode::Wildcard(_) => write!(f, "Wildcard"),
            RefNode::BinsOrOptionsCoverPoint(_) => write!(f, "BinsOrOptionsCoverPoint"),
            RefNode::BinsOrOptionsSetCovergroup(_) => write!(f, "BinsOrOptionsSetCovergroup"),
            RefNode::BinsOrOptionsTransList(_) => write!(f, "BinsOrOptionsTransList"),
            RefNode::BinsOrOptionsDefault(_) => write!(f, "BinsOrOptionsDefault"),
            RefNode::BinsOrOptionsDefaultSequence(_) => write!(f, "BinsOrOptionsDefaultSequence"),
            RefNode::BinsKeyword(_) => write!(f, "BinsKeyword"),
            RefNode::TransList(_) => write!(f, "TransList"),
            RefNode::TransSet(_) => write!(f, "TransSet"),
            RefNode::TransRangeList(_) => write!(f, "TransRangeList"),
            RefNode::TransRangeListAsterisk(_) => write!(f, "TransRangeListAsterisk"),
            RefNode::TransRangeListArrow(_) => write!(f, "TransRangeListArrow"),
            RefNode::TransRangeListEqual(_) => write!(f, "TransRangeListEqual"),
            RefNode::TransItem(_) => write!(f, "TransItem"),
            RefNode::RepeatRange(_) => write!(f, "RepeatRange"),
            RefNode::RepeatRangeBinary(_) => write!(f, "RepeatRangeBinary"),
            RefNode::CoverCross(_) => write!(f, "CoverCross"),
            RefNode::ListOfCrossItems(_) => write!(f, "ListOfCrossItems"),
            RefNode::CrossItem(_) => write!(f, "CrossItem"),
            RefNode::CrossBody(_) => write!(f, "CrossBody"),
            RefNode::CrossBodyNonEmpty(_) => write!(f, "CrossBodyNonEmpty"),
            RefNode::CrossBodyItem(_) => write!(f, "CrossBodyItem"),
            RefNode::BinsSelectionOrOption(_) => write!(f, "BinsSelectionOrOption"),
            RefNode::BinsSelectionOrOptionCoverage(_) => write!(f, "BinsSelectionOrOptionCoverage"),
            RefNode::BinsSelectionOrOptionBins(_) => write!(f, "BinsSelectionOrOptionBins"),
            RefNode::BinsSelection(_) => write!(f, "BinsSelection"),
            RefNode::SelectExpression(_) => write!(f, "SelectExpression"),
            RefNode::SelectExpressionNot(_) => write!(f, "SelectExpressionNot"),
            RefNode::SelectExpressionAnd(_) => write!(f, "SelectExpressionAnd"),
            RefNode::SelectExpressionOr(_) => write!(f, "SelectExpressionOr"),
            RefNode::SelectExpressionParen(_) => write!(f, "SelectExpressionParen"),
            RefNode::SelectExpressionWith(_) => write!(f, "SelectExpressionWith"),
            RefNode::SelectExpressionCrossSet(_) => write!(f, "SelectExpressionCrossSet"),
            RefNode::SelectCondition(_) => write!(f, "SelectCondition"),
            RefNode::BinsExpression(_) => write!(f, "BinsExpression"),
            RefNode::BinsExpressionCoverPoint(_) => write!(f, "BinsExpressionCoverPoint"),
            RefNode::CovergroupRangeList(_) => write!(f, "CovergroupRangeList"),
            RefNode::CovergroupValueRange(_) => write!(f, "CovergroupValueRange"),
            RefNode::CovergroupValueRangeBinary(_) => write!(f, "CovergroupValueRangeBinary"),
            RefNode::WithCovergroupExpression(_) => write!(f, "WithCovergroupExpression"),
            RefNode::SetCovergroupExpression(_) => write!(f, "SetCovergroupExpression"),
            RefNode::IntegerCovergroupExpression(_) => write!(f, "IntegerCovergroupExpression"),
            RefNode::CrossSetExpression(_) => write!(f, "CrossSetExpression"),
            RefNode::CovergroupExpression(_) => write!(f, "CovergroupExpression"),
            RefNode::BlockItemDeclaration(_) => write!(f, "BlockItemDeclaration"),
            RefNode::BlockItemDeclarationData(_) => write!(f, "BlockItemDeclarationData"),
            RefNode::BlockItemDeclarationLocalParameter(_) => write!(f, "BlockItemDeclarationLocalParameter"),
            RefNode::BlockItemDeclarationParameter(_) => write!(f, "BlockItemDeclarationParameter"),
            RefNode::BlockItemDeclarationLet(_) => write!(f, "BlockItemDeclarationLet"),
            RefNode::Delay3(_) => write!(f, "Delay3"),
            RefNode::Delay3Single(_) => write!(f, "Delay3Single"),
            RefNode::Delay3Mintypmax(_) => write!(f, "Delay3Mintypmax"),
            RefNode::Delay2(_) => write!(f, "Delay2"),
            RefNode::Delay2Single(_) => write!(f, "Delay2Single"),
            RefNode::Delay2Mintypmax(_) => write!(f, "Delay2Mintypmax"),
            RefNode::DelayValue(_) => write!(f, "DelayValue"),
            RefNode::ModportDeclaration(_) => write!(f, "ModportDeclaration"),
            RefNode::ModportItem(_) => write!(f, "ModportItem"),
            RefNode::ModportPortsDeclaration(_) => write!(f, "ModportPortsDeclaration"),
            RefNode::ModportPortsDeclarationSimple(_) => write!(f, "ModportPortsDeclarationSimple"),
            RefNode::ModportPortsDeclarationTf(_) => write!(f, "ModportPortsDeclarationTf"),
            RefNode::ModportPortsDeclarationClocking(_) => write!(f, "ModportPortsDeclarationClocking"),
            RefNode::ModportClockingDeclaration(_) => write!(f, "ModportClockingDeclaration"),
            RefNode::ModportSimplePortsDeclaration(_) => write!(f, "ModportSimplePortsDeclaration"),
            RefNode::ModportSimplePort(_) => write!(f, "ModportSimplePort"),
            RefNode::ModportSimplePortOrdered(_) => write!(f, "ModportSimplePortOrdered"),
            RefNode::ModportSimplePortNamed(_) => write!(f, "ModportSimplePortNamed"),
            RefNode::ModportTfPortsDeclaration(_) => write!(f, "ModportTfPortsDeclaration"),
            RefNode::ModportTfPort(_) => write!(f, "ModportTfPort"),
            RefNode::ImportExport(_) => write!(f, "ImportExport"),
            RefNode::CastingType(_) => write!(f, "CastingType"),
            RefNode::DataType(_) => write!(f, "DataType"),
            RefNode::DataTypeVector(_) => write!(f, "DataTypeVector"),
            RefNode::DataTypeAtom(_) => write!(f, "DataTypeAtom"),
            RefNode::DataTypeStructUnion(_) => write!(f, "DataTypeStructUnion"),
            RefNode::Packed(_) => write!(f, "Packed"),
            RefNode::DataTypeEnum(_) => write!(f, "DataTypeEnum"),
            RefNode::DataTypeVirtual(_) => write!(f, "DataTypeVirtual"),
            RefNode::Interface(_) => write!(f, "Interface"),
            RefNode::DataTypeType(_) => write!(f, "DataTypeType"),
            RefNode::DataTypeOrImplicit(_) => write!(f, "DataTypeOrImplicit"),
            RefNode::ImplicitDataType(_) => write!(f, "ImplicitDataType"),
            RefNode::EnumBaseType(_) => write!(f, "EnumBaseType"),
            RefNode::EnumBaseTypeAtom(_) => write!(f, "EnumBaseTypeAtom"),
            RefNode::EnumBaseTypeVector(_) => write!(f, "EnumBaseTypeVector"),
            RefNode::EnumBaseTypeType(_) => write!(f, "EnumBaseTypeType"),
            RefNode::EnumNameDeclaration(_) => write!(f, "EnumNameDeclaration"),
            RefNode::ClassScope(_) => write!(f, "ClassScope"),
            RefNode::ClassType(_) => write!(f, "ClassType"),
            RefNode::IntegerType(_) => write!(f, "IntegerType"),
            RefNode::IntegerAtomType(_) => write!(f, "IntegerAtomType"),
            RefNode::IntegerVectorType(_) => write!(f, "IntegerVectorType"),
            RefNode::NonIntegerType(_) => write!(f, "NonIntegerType"),
            RefNode::NetType(_) => write!(f, "NetType"),
            RefNode::NetPortType(_) => write!(f, "NetPortType"),
            RefNode::NetPortTypeDataType(_) => write!(f, "NetPortTypeDataType"),
            RefNode::NetPortTypeInterconnect(_) => write!(f, "NetPortTypeInterconnect"),
            RefNode::VariablePortType(_) => write!(f, "VariablePortType"),
            RefNode::VarDataType(_) => write!(f, "VarDataType"),
            RefNode::VarDataTypeVar(_) => write!(f, "VarDataTypeVar"),
            RefNode::Signing(_) => write!(f, "Signing"),
            RefNode::SimpleType(_) => write!(f, "SimpleType"),
            RefNode::StructUnionMember(_) => write!(f, "StructUnionMember"),
            RefNode::DataTypeOrVoid(_) => write!(f, "DataTypeOrVoid"),
            RefNode::StructUnion(_) => write!(f, "StructUnion"),
            RefNode::TypeReference(_) => write!(f, "TypeReference"),
            RefNode::TypeReferenceExpression(_) => write!(f, "TypeReferenceExpression"),
            RefNode::TypeReferenceDataType(_) => write!(f, "TypeReferenceDataType"),
            RefNode::FunctionDataTypeOrImplicit(_) => write!(f, "FunctionDataTypeOrImplicit"),
            RefNode::FunctionDeclaration(_) => write!(f, "FunctionDeclaration"),
            RefNode::FunctionBodyDeclaration(_) => write!(f, "FunctionBodyDeclaration"),
            RefNode::FunctionBodyDeclarationWithoutPort(_) => write!(f, "FunctionBodyDeclarationWithoutPort"),
            RefNode::FunctionBodyDeclarationWithPort(_) => write!(f, "FunctionBodyDeclarationWithPort"),
            RefNode::InterfaceIdentifierOrClassScope(_) => write!(f, "InterfaceIdentifierOrClassScope"),
            RefNode::FunctionPrototype(_) => write!(f, "FunctionPrototype"),
            RefNode::DpiImportExport(_) => write!(f, "DpiImportExport"),
            RefNode::DpiImportExportImportFunction(_) => write!(f, "DpiImportExportImportFunction"),
            RefNode::DpiImportExportImportTask(_) => write!(f, "DpiImportExportImportTask"),
            RefNode::DpiImportExportExportFunction(_) => write!(f, "DpiImportExportExportFunction"),
            RefNode::DpiImportExportExportTask(_) => write!(f, "DpiImportExportExportTask"),
            RefNode::DpiSpecString(_) => write!(f, "DpiSpecString"),
            RefNode::DpiFunctionImportProperty(_) => write!(f, "DpiFunctionImportProperty"),
            RefNode::DpiTaskImportProperty(_) => write!(f, "DpiTaskImportProperty"),
            RefNode::DpiFunctionProto(_) => write!(f, "DpiFunctionProto"),
            RefNode::DpiTaskProto(_) => write!(f, "DpiTaskProto"),
            RefNode::Symbol(_) => write!(f, "Symbol"),
            RefNode::Keyword(_) => write!(f, "Keyword"),
            RefNode::WhiteSpace(_) => write!(f, "WhiteSpace"),
            RefNode::TimingCheckEvent(_) => write!(f, "TimingCheckEvent"),
            RefNode::ControlledTimingCheckEvent(_) => write!(f, "ControlledTimingCheckEvent"),
            RefNode::TimingCheckEventControl(_) => write!(f, "TimingCheckEventControl"),
            RefNode::SpecifyTerminalDescriptor(_) => write!(f, "SpecifyTerminalDescriptor"),
            RefNode::EdgeControlSpecifier(_) => write!(f, "EdgeControlSpecifier"),
            RefNode::EdgeDescriptor(_) => write!(f, "EdgeDescriptor"),
            RefNode::TimingCheckCondition(_) => write!(f, "TimingCheckCondition"),
            RefNode::TimingCheckConditionParen(_) => write!(f, "TimingCheckConditionParen"),
            RefNode::ScalarTimingCheckCondition(_) => write!(f, "ScalarTimingCheckCondition"),
            RefNode::ScalarTimingCheckConditionUnary(_) => write!(f, "ScalarTimingCheckConditionUnary"),
            RefNode::ScalarTimingCheckConditionBinary(_) => write!(f, "ScalarTimingCheckConditionBinary"),
            RefNode::ScalarConstant(_) => write!(f, "ScalarConstant"),
            RefNode::SpecifyBlock(_) => write!(f, "SpecifyBlock"),
            RefNode::SpecifyItem(_) => write!(f, "SpecifyItem"),
            RefNode::PulsestyleDeclaration(_) => write!(f, "PulsestyleDeclaration"),
            RefNode::ShowcancelledDeclaration(_) => write!(f, "ShowcancelledDeclaration"),
            RefNode::SystemTimingCheck(_) => write!(f, "SystemTimingCheck"),
            RefNode::SetupTimingCheck(_) => write!(f, "SetupTimingCheck"),
            RefNode::HoldTimingCheck(_) => write!(f, "HoldTimingCheck"),
            RefNode::SetupholdTimingCheck(_) => write!(f, "SetupholdTimingCheck"),
            RefNode::RecoveryTimingCheck(_) => write!(f, "RecoveryTimingCheck"),
            RefNode::RemovalTimingCheck(_) => write!(f, "RemovalTimingCheck"),
            RefNode::RecremTimingCheck(_) => write!(f, "RecremTimingCheck"),
            RefNode::SkewTimingCheck(_) => write!(f, "SkewTimingCheck"),
            RefNode::TimeskewTimingCheck(_) => write!(f, "TimeskewTimingCheck"),
            RefNode::FullskewTimingCheck(_) => write!(f, "FullskewTimingCheck"),
            RefNode::PeriodTimingCheck(_) => write!(f, "PeriodTimingCheck"),
            RefNode::WidthTimingCheck(_) => write!(f, "WidthTimingCheck"),
            RefNode::NochangeTimingCheck(_) => write!(f, "NochangeTimingCheck"),
            RefNode::PathDelayValue(_) => write!(f, "PathDelayValue"),
            RefNode::PathDelayValueParen(_) => write!(f, "PathDelayValueParen"),
            RefNode::ListOfPathDelayExpressions(_) => write!(f, "ListOfPathDelayExpressions"),
            RefNode::TPathDelayExpression(_) => write!(f, "TPathDelayExpression"),
            RefNode::PathDelayExpression(_) => write!(f, "PathDelayExpression"),
            RefNode::EdgeSensitivePathDeclaration(_) => write!(f, "EdgeSensitivePathDeclaration"),
            RefNode::EdgeSensitivePathDeclarationParallel(_) => write!(f, "EdgeSensitivePathDeclarationParallel"),
            RefNode::EdgeSensitivePathDeclarationFull(_) => write!(f, "EdgeSensitivePathDeclarationFull"),
            RefNode::ParallelEdgeSensitivePathDescription(_) => write!(f, "ParallelEdgeSensitivePathDescription"),
            RefNode::FullEdgeSensitivePathDescription(_) => write!(f, "FullEdgeSensitivePathDescription"),
            RefNode::DataSourceExpression(_) => write!(f, "DataSourceExpression"),
            RefNode::EdgeIdentifier(_) => write!(f, "EdgeIdentifier"),
            RefNode::StateDependentPathDeclaration(_) => write!(f, "StateDependentPathDeclaration"),
            RefNode::StateDependentPathDeclarationIfSimple(_) => write!(f, "StateDependentPathDeclarationIfSimple"),
            RefNode::StateDependentPathDeclarationIfEdgeSensitive(_) => write!(f, "StateDependentPathDeclarationIfEdgeSensitive"),
            RefNode::StateDependentPathDeclarationIfNone(_) => write!(f, "StateDependentPathDeclarationIfNone"),
            RefNode::PolarityOperator(_) => write!(f, "PolarityOperator"),
            RefNode::TimecheckCondition(_) => write!(f, "TimecheckCondition"),
            RefNode::ControlledReferenceEvent(_) => write!(f, "ControlledReferenceEvent"),
            RefNode::DataEvent(_) => write!(f, "DataEvent"),
            RefNode::DelayedData(_) => write!(f, "DelayedData"),
            RefNode::DelayedDataWithMintypmax(_) => write!(f, "DelayedDataWithMintypmax"),
            RefNode::DelayedReference(_) => write!(f, "DelayedReference"),
            RefNode::DelayedReferenceWithMintypmax(_) => write!(f, "DelayedReferenceWithMintypmax"),
            RefNode::EndEdgeOffset(_) => write!(f, "EndEdgeOffset"),
            RefNode::EventBasedFlag(_) => write!(f, "EventBasedFlag"),
            RefNode::Notifier(_) => write!(f, "Notifier"),
            RefNode::ReferenceEvent(_) => write!(f, "ReferenceEvent"),
            RefNode::RemainActiveFlag(_) => write!(f, "RemainActiveFlag"),
            RefNode::TimestampCondition(_) => write!(f, "TimestampCondition"),
            RefNode::StartEdgeOffset(_) => write!(f, "StartEdgeOffset"),
            RefNode::Threshold(_) => write!(f, "Threshold"),
            RefNode::TimingCheckLimit(_) => write!(f, "TimingCheckLimit"),
            RefNode::PathDeclaration(_) => write!(f, "PathDeclaration"),
            RefNode::SimplePathDeclaration(_) => write!(f, "SimplePathDeclaration"),
            RefNode::SimplePathDeclarationParallel(_) => write!(f, "SimplePathDeclarationParallel"),
            RefNode::SimplePathDeclarationFull(_) => write!(f, "SimplePathDeclarationFull"),
            RefNode::ParallelPathDescription(_) => write!(f, "ParallelPathDescription"),
            RefNode::FullPathDescription(_) => write!(f, "FullPathDescription"),
            RefNode::ListOfPathInputs(_) => write!(f, "ListOfPathInputs"),
            RefNode::ListOfPathOutputs(_) => write!(f, "ListOfPathOutputs"),
            RefNode::SpecifyInputTerminalDescriptor(_) => write!(f, "SpecifyInputTerminalDescriptor"),
            RefNode::SpecifyOutputTerminalDescriptor(_) => write!(f, "SpecifyOutputTerminalDescriptor"),
            RefNode::InputIdentifier(_) => write!(f, "InputIdentifier"),
            RefNode::InputIdentifierInterface(_) => write!(f, "InputIdentifierInterface"),
            RefNode::OutputIdentifier(_) => write!(f, "OutputIdentifier"),
            RefNode::OutputIdentifierInterface(_) => write!(f, "OutputIdentifierInterface"),
            RefNode::LoopStatement(_) => write!(f, "LoopStatement"),
            RefNode::LoopStatementForever(_) => write!(f, "LoopStatementForever"),
            RefNode::LoopStatementRepeat(_) => write!(f, "LoopStatementRepeat"),
            RefNode::LoopStatementWhile(_) => write!(f, "LoopStatementWhile"),
            RefNode::LoopStatementFor(_) => write!(f, "LoopStatementFor"),
            RefNode::LoopStatementDoWhile(_) => write!(f, "LoopStatementDoWhile"),
            RefNode::LoopStatementForeach(_) => write!(f, "LoopStatementForeach"),
            RefNode::ForInitialization(_) => write!(f, "ForInitialization"),
            RefNode::ForInitializationDeclaration(_) => write!(f, "ForInitializationDeclaration"),
            RefNode::ForVariableDeclaration(_) => write!(f, "ForVariableDeclaration"),
            RefNode::Var(_) => write!(f, "Var"),
            RefNode::ForStep(_) => write!(f, "ForStep"),
            RefNode::ForStepAssignment(_) => write!(f, "ForStepAssignment"),
            RefNode::LoopVariables(_) => write!(f, "LoopVariables"),
            RefNode::CaseStatement(_) => write!(f, "CaseStatement"),
            RefNode::CaseStatementNormal(_) => write!(f, "CaseStatementNormal"),
            RefNode::CaseStatementMatches(_) => write!(f, "CaseStatementMatches"),
            RefNode::CaseStatementInside(_) => write!(f, "CaseStatementInside"),
            RefNode::CaseKeyword(_) => write!(f, "CaseKeyword"),
            RefNode::CaseExpression(_) => write!(f, "CaseExpression"),
            RefNode::CaseItem(_) => write!(f, "CaseItem"),
            RefNode::CaseItemNondefault(_) => write!(f, "CaseItemNondefault"),
            RefNode::CaseItemDefault(_) => write!(f, "CaseItemDefault"),
            RefNode::CasePatternItem(_) => write!(f, "CasePatternItem"),
            RefNode::CasePatternItemNondefault(_) => write!(f, "CasePatternItemNondefault"),
            RefNode::CaseInsideItem(_) => write!(f, "CaseInsideItem"),
            RefNode::CaseInsideItemNondefault(_) => write!(f, "CaseInsideItemNondefault"),
            RefNode::CaseItemExpression(_) => write!(f, "CaseItemExpression"),
            RefNode::RandcaseStatement(_) => write!(f, "RandcaseStatement"),
            RefNode::RandcaseItem(_) => write!(f, "RandcaseItem"),
            RefNode::OpenRangeList(_) => write!(f, "OpenRangeList"),
            RefNode::OpenValueRange(_) => write!(f, "OpenValueRange"),
            RefNode::ContinuousAssign(_) => write!(f, "ContinuousAssign"),
            RefNode::ContinuousAssignNet(_) => write!(f, "ContinuousAssignNet"),
            RefNode::ContinuousAssignVariable(_) => write!(f, "ContinuousAssignVariable"),
            RefNode::ListOfNetAssignments(_) => write!(f, "ListOfNetAssignments"),
            RefNode::ListOfVariableAssignments(_) => write!(f, "ListOfVariableAssignments"),
            RefNode::NetAlias(_) => write!(f, "NetAlias"),
            RefNode::NetAssignment(_) => write!(f, "NetAssignment"),
            RefNode::ConditionalStatement(_) => write!(f, "ConditionalStatement"),
            RefNode::UniquePriority(_) => write!(f, "UniquePriority"),
            RefNode::CondPredicate(_) => write!(f, "CondPredicate"),
            RefNode::ExpressionOrCondPattern(_) => write!(f, "ExpressionOrCondPattern"),
            RefNode::CondPattern(_) => write!(f, "CondPattern"),
            RefNode::ProceduralTimingControlStatement(_) => write!(f, "ProceduralTimingControlStatement"),
            RefNode::DelayOrEventControl(_) => write!(f, "DelayOrEventControl"),
            RefNode::DelayOrEventControlRepeat(_) => write!(f, "DelayOrEventControlRepeat"),
            RefNode::DelayControl(_) => write!(f, "DelayControl"),
            RefNode::DelayControlDelay(_) => write!(f, "DelayControlDelay"),
            RefNode::DelayControlMintypmax(_) => write!(f, "DelayControlMintypmax"),
            RefNode::EventControl(_) => write!(f, "EventControl"),
            RefNode::EventControlEventIdentifier(_) => write!(f, "EventControlEventIdentifier"),
            RefNode::EventControlEventExpression(_) => write!(f, "EventControlEventExpression"),
            RefNode::EventControlAsterisk(_) => write!(f, "EventControlAsterisk"),
            RefNode::EventControlParenAsterisk(_) => write!(f, "EventControlParenAsterisk"),
            RefNode::EventControlSequenceIdentifier(_) => write!(f, "EventControlSequenceIdentifier"),
            RefNode::EventExpression(_) => write!(f, "EventExpression"),
            RefNode::EventExpressionExpression(_) => write!(f, "EventExpressionExpression"),
            RefNode::EventExpressionSequence(_) => write!(f, "EventExpressionSequence"),
            RefNode::EventExpressionOr(_) => write!(f, "EventExpressionOr"),
            RefNode::EventExpressionComma(_) => write!(f, "EventExpressionComma"),
            RefNode::EventExpressionParen(_) => write!(f, "EventExpressionParen"),
            RefNode::ProceduralTimingControl(_) => write!(f, "ProceduralTimingControl"),
            RefNode::JumpStatement(_) => write!(f, "JumpStatement"),
            RefNode::JumpStatementReturn(_) => write!(f, "JumpStatementReturn"),
            RefNode::JumpStatementBreak(_) => write!(f, "JumpStatementBreak"),
            RefNode::JumpStatementContinue(_) => write!(f, "JumpStatementContinue"),
            RefNode::WaitStatement(_) => write!(f, "WaitStatement"),
            RefNode::WaitStatementWait(_) => write!(f, "WaitStatementWait"),
            RefNode::WaitStatementFork(_) => write!(f, "WaitStatementFork"),
            RefNode::WaitStatementOrder(_) => write!(f, "WaitStatementOrder"),
            RefNode::EventTrigger(_) => write!(f, "EventTrigger"),
            RefNode::EventTriggerNamed(_) => write!(f, "EventTriggerNamed"),
            RefNode::EventTriggerNonblocking(_) => write!(f, "EventTriggerNonblocking"),
            RefNode::DisableStatement(_) => write!(f, "DisableStatement"),
            RefNode::DisableStatementTask(_) => write!(f, "DisableStatementTask"),
            RefNode::DisableStatementBlock(_) => write!(f, "DisableStatementBlock"),
            RefNode::DisableStatementFork(_) => write!(f, "DisableStatementFork"),
            RefNode::RandsequenceStatement(_) => write!(f, "RandsequenceStatement"),
            RefNode::Production(_) => write!(f, "Production"),
            RefNode::RsRule(_) => write!(f, "RsRule"),
            RefNode::RsProductionList(_) => write!(f, "RsProductionList"),
            RefNode::RsProductionListProd(_) => write!(f, "RsProductionListProd"),
            RefNode::RsProductionListJoin(_) => write!(f, "RsProductionListJoin"),
            RefNode::WeightSpecification(_) => write!(f, "WeightSpecification"),
            RefNode::WeightSpecificationExpression(_) => write!(f, "WeightSpecificationExpression"),
            RefNode::RsCodeBlock(_) => write!(f, "RsCodeBlock"),
            RefNode::RsProd(_) => write!(f, "RsProd"),
            RefNode::ProductionItem(_) => write!(f, "ProductionItem"),
            RefNode::RsIfElse(_) => write!(f, "RsIfElse"),
            RefNode::RsRepeat(_) => write!(f, "RsRepeat"),
            RefNode::RsCase(_) => write!(f, "RsCase"),
            RefNode::RsCaseItem(_) => write!(f, "RsCaseItem"),
            RefNode::RsCaseItemNondefault(_) => write!(f, "RsCaseItemNondefault"),
            RefNode::RsCaseItemDefault(_) => write!(f, "RsCaseItemDefault"),
            RefNode::Pattern(_) => write!(f, "Pattern"),
            RefNode::PatternVariable(_) => write!(f, "PatternVariable"),
            RefNode::PatternTagged(_) => write!(f, "PatternTagged"),
            RefNode::PatternList(_) => write!(f, "PatternList"),
            RefNode::PatternIdentifierList(_) => write!(f, "PatternIdentifierList"),
            RefNode::AssignmentPattern(_) => write!(f, "AssignmentPattern"),
            RefNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"),
            RefNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"),
            RefNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"),
            RefNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"),
            RefNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"),
            RefNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"),
            RefNode::AssignmentPatternKey(_) => write!(f, "AssignmentPatternKey"),
            RefNode::AssignmentPatternExpression(_) => write!(f, "AssignmentPatternExpression"),
            RefNode::AssignmentPatternExpressionType(_) => write!(f, "AssignmentPatternExpressionType"),
            RefNode::ConstantAssignmentPatternExpression(_) => write!(f, "ConstantAssignmentPatternExpression"),
            RefNode::AssignmentPatternNetLvalue(_) => write!(f, "AssignmentPatternNetLvalue"),
            RefNode::AssignmentPatternVariableLvalue(_) => write!(f, "AssignmentPatternVariableLvalue"),
            RefNode::AssertionItem(_) => write!(f, "AssertionItem"),
            RefNode::DeferredImmediateAssetionItem(_) => write!(f, "DeferredImmediateAssetionItem"),
            RefNode::ProceduralAssertionStatement(_) => write!(f, "ProceduralAssertionStatement"),
            RefNode::ImmediateAssetionStatement(_) => write!(f, "ImmediateAssetionStatement"),
            RefNode::SimpleImmediateAssertionStatement(_) => write!(f, "SimpleImmediateAssertionStatement"),
            RefNode::SimpleImmediateAssertStatement(_) => write!(f, "SimpleImmediateAssertStatement"),
            RefNode::SimpleImmediateAssumeStatement(_) => write!(f, "SimpleImmediateAssumeStatement"),
            RefNode::SimpleImmediateCoverStatement(_) => write!(f, "SimpleImmediateCoverStatement"),
            RefNode::DeferredImmediateAssertionStatement(_) => write!(f, "DeferredImmediateAssertionStatement"),
            RefNode::DeferredImmediateAssertStatement(_) => write!(f, "DeferredImmediateAssertStatement"),
            RefNode::DeferredImmediateAssumeStatement(_) => write!(f, "DeferredImmediateAssumeStatement"),
            RefNode::DeferredImmediateCoverStatement(_) => write!(f, "DeferredImmediateCoverStatement"),
            RefNode::AssertTiming(_) => write!(f, "AssertTiming"),
            RefNode::InitialConstruct(_) => write!(f, "InitialConstruct"),
            RefNode::AlwaysConstruct(_) => write!(f, "AlwaysConstruct"),
            RefNode::AlwaysKeyword(_) => write!(f, "AlwaysKeyword"),
            RefNode::FinalConstruct(_) => write!(f, "FinalConstruct"),
            RefNode::BlockingAssignment(_) => write!(f, "BlockingAssignment"),
            RefNode::BlockingAssignmentVariable(_) => write!(f, "BlockingAssignmentVariable"),
            RefNode::BlockingAssignmentNonrangeVariable(_) => write!(f, "BlockingAssignmentNonrangeVariable"),
            RefNode::BlockingAssignmentHierarchicalVariable(_) => write!(f, "BlockingAssignmentHierarchicalVariable"),
            RefNode::OperatorAssignment(_) => write!(f, "OperatorAssignment"),
            RefNode::AssignmentOperator(_) => write!(f, "AssignmentOperator"),
            RefNode::NonblockingAssignment(_) => write!(f, "NonblockingAssignment"),
            RefNode::ProceduralContinuousAssignment(_) => write!(f, "ProceduralContinuousAssignment"),
            RefNode::ProceduralContinuousAssignmentAssign(_) => write!(f, "ProceduralContinuousAssignmentAssign"),
            RefNode::ProceduralContinuousAssignmentDeassign(_) => write!(f, "ProceduralContinuousAssignmentDeassign"),
            RefNode::ProceduralContinuousAssignmentForceVariable(_) => write!(f, "ProceduralContinuousAssignmentForceVariable"),
            RefNode::ProceduralContinuousAssignmentForceNet(_) => write!(f, "ProceduralContinuousAssignmentForceNet"),
            RefNode::ProceduralContinuousAssignmentReleaseVariable(_) => write!(f, "ProceduralContinuousAssignmentReleaseVariable"),
            RefNode::ProceduralContinuousAssignmentReleaseNet(_) => write!(f, "ProceduralContinuousAssignmentReleaseNet"),
            RefNode::VariableAssignment(_) => write!(f, "VariableAssignment"),
            RefNode::SubroutineCallStatement(_) => write!(f, "SubroutineCallStatement"),
            RefNode::SubroutineCallStatementFunction(_) => write!(f, "SubroutineCallStatementFunction"),
            RefNode::ClockingDeclaration(_) => write!(f, "ClockingDeclaration"),
            RefNode::ClockingDeclarationLocal(_) => write!(f, "ClockingDeclarationLocal"),
            RefNode::Default(_) => write!(f, "Default"),
            RefNode::ClockingDeclarationGlobal(_) => write!(f, "ClockingDeclarationGlobal"),
            RefNode::ClockingEvent(_) => write!(f, "ClockingEvent"),
            RefNode::ClockingEventIdentifier(_) => write!(f, "ClockingEventIdentifier"),
            RefNode::ClockingEventExpression(_) => write!(f, "ClockingEventExpression"),
            RefNode::ClockingItem(_) => write!(f, "ClockingItem"),
            RefNode::ClockingItemDefault(_) => write!(f, "ClockingItemDefault"),
            RefNode::ClockingItemDirection(_) => write!(f, "ClockingItemDirection"),
            RefNode::ClockingItemAssertion(_) => write!(f, "ClockingItemAssertion"),
            RefNode::DefaultSkew(_) => write!(f, "DefaultSkew"),
            RefNode::DefaultSkewInput(_) => write!(f, "DefaultSkewInput"),
            RefNode::DefaultSkewOutput(_) => write!(f, "DefaultSkewOutput"),
            RefNode::DefaultSkewInputOutput(_) => write!(f, "DefaultSkewInputOutput"),
            RefNode::ClockingDirection(_) => write!(f, "ClockingDirection"),
            RefNode::ClockingDirectionInput(_) => write!(f, "ClockingDirectionInput"),
            RefNode::ClockingDirectionOutput(_) => write!(f, "ClockingDirectionOutput"),
            RefNode::ClockingDirectionInputOutput(_) => write!(f, "ClockingDirectionInputOutput"),
            RefNode::ListOfClockingDeclAssign(_) => write!(f, "ListOfClockingDeclAssign"),
            RefNode::ClockingDeclAssign(_) => write!(f, "ClockingDeclAssign"),
            RefNode::ClockingSkew(_) => write!(f, "ClockingSkew"),
            RefNode::ClockingSkewEdge(_) => write!(f, "ClockingSkewEdge"),
            RefNode::ClockingDrive(_) => write!(f, "ClockingDrive"),
            RefNode::CycleDelay(_) => write!(f, "CycleDelay"),
            RefNode::CycleDelayIntegral(_) => write!(f, "CycleDelayIntegral"),
            RefNode::CycleDelayIdentifier(_) => write!(f, "CycleDelayIdentifier"),
            RefNode::CycleDelayExpression(_) => write!(f, "CycleDelayExpression"),
            RefNode::Clockvar(_) => write!(f, "Clockvar"),
            RefNode::ClockvarExpression(_) => write!(f, "ClockvarExpression"),
            RefNode::ActionBlock(_) => write!(f, "ActionBlock"),
            RefNode::ActionBlockElse(_) => write!(f, "ActionBlockElse"),
            RefNode::SeqBlock(_) => write!(f, "SeqBlock"),
            RefNode::ParBlock(_) => write!(f, "ParBlock"),
            RefNode::JoinKeyword(_) => write!(f, "JoinKeyword"),
            RefNode::StatementOrNull(_) => write!(f, "StatementOrNull"),
            RefNode::StatementOrNullAttribute(_) => write!(f, "StatementOrNullAttribute"),
            RefNode::Statement(_) => write!(f, "Statement"),
            RefNode::StatementItem(_) => write!(f, "StatementItem"),
            RefNode::FunctionStatement(_) => write!(f, "FunctionStatement"),
            RefNode::FunctionStatementOrNull(_) => write!(f, "FunctionStatementOrNull"),
            RefNode::FunctionStatementOrNullAttribute(_) => write!(f, "FunctionStatementOrNullAttribute"),
            RefNode::VariableIdentifierList(_) => write!(f, "VariableIdentifierList"),
            RefNode::UdpInstantiation(_) => write!(f, "UdpInstantiation"),
            RefNode::UdpInstance(_) => write!(f, "UdpInstance"),
            RefNode::UdpNonansiDeclaration(_) => write!(f, "UdpNonansiDeclaration"),
            RefNode::UdpAnsiDeclaration(_) => write!(f, "UdpAnsiDeclaration"),
            RefNode::UdpDeclaration(_) => write!(f, "UdpDeclaration"),
            RefNode::UdpDeclarationNonansi(_) => write!(f, "UdpDeclarationNonansi"),
            RefNode::UdpDeclarationAnsi(_) => write!(f, "UdpDeclarationAnsi"),
            RefNode::UdpDeclarationExternNonansi(_) => write!(f, "UdpDeclarationExternNonansi"),
            RefNode::UdpDeclarationExternAnsi(_) => write!(f, "UdpDeclarationExternAnsi"),
            RefNode::UdpDeclarationWildcard(_) => write!(f, "UdpDeclarationWildcard"),
            RefNode::UdpBody(_) => write!(f, "UdpBody"),
            RefNode::CombinationalBody(_) => write!(f, "CombinationalBody"),
            RefNode::CombinationalEntry(_) => write!(f, "CombinationalEntry"),
            RefNode::SequentialBody(_) => write!(f, "SequentialBody"),
            RefNode::UdpInitialStatement(_) => write!(f, "UdpInitialStatement"),
            RefNode::InitVal(_) => write!(f, "InitVal"),
            RefNode::SequentialEntry(_) => write!(f, "SequentialEntry"),
            RefNode::SeqInputList(_) => write!(f, "SeqInputList"),
            RefNode::LevelInputList(_) => write!(f, "LevelInputList"),
            RefNode::EdgeInputList(_) => write!(f, "EdgeInputList"),
            RefNode::EdgeIndicator(_) => write!(f, "EdgeIndicator"),
            RefNode::EdgeIndicatorParen(_) => write!(f, "EdgeIndicatorParen"),
            RefNode::CurrentState(_) => write!(f, "CurrentState"),
            RefNode::NextState(_) => write!(f, "NextState"),
            RefNode::OutputSymbol(_) => write!(f, "OutputSymbol"),
            RefNode::LevelSymbol(_) => write!(f, "LevelSymbol"),
            RefNode::EdgeSymbol(_) => write!(f, "EdgeSymbol"),
            RefNode::UdpPortList(_) => write!(f, "UdpPortList"),
            RefNode::UdpDeclarationPortList(_) => write!(f, "UdpDeclarationPortList"),
            RefNode::UdpPortDeclaration(_) => write!(f, "UdpPortDeclaration"),
            RefNode::UdpOutputDeclaration(_) => write!(f, "UdpOutputDeclaration"),
            RefNode::UdpOutputDeclarationNonreg(_) => write!(f, "UdpOutputDeclarationNonreg"),
            RefNode::UdpOutputDeclarationReg(_) => write!(f, "UdpOutputDeclarationReg"),
            RefNode::UdpInputDeclaration(_) => write!(f, "UdpInputDeclaration"),
            RefNode::UdpRegDeclaration(_) => write!(f, "UdpRegDeclaration"),
            RefNode::InterfaceInstantiation(_) => write!(f, "InterfaceInstantiation"),
            RefNode::CheckerInstantiation(_) => write!(f, "CheckerInstantiation"),
            RefNode::ListOfCheckerPortConnections(_) => write!(f, "ListOfCheckerPortConnections"),
            RefNode::ListOfCheckerPortConnectionsOrdered(_) => write!(f, "ListOfCheckerPortConnectionsOrdered"),
            RefNode::ListOfCheckerPortConnectionsNamed(_) => write!(f, "ListOfCheckerPortConnectionsNamed"),
            RefNode::OrderedCheckerPortConnection(_) => write!(f, "OrderedCheckerPortConnection"),
            RefNode::NamedCheckerPortConnection(_) => write!(f, "NamedCheckerPortConnection"),
            RefNode::NamedCheckerPortConnectionIdentifier(_) => write!(f, "NamedCheckerPortConnectionIdentifier"),
            RefNode::NamedCheckerPortConnectionAsterisk(_) => write!(f, "NamedCheckerPortConnectionAsterisk"),
            RefNode::ModuleInstantiation(_) => write!(f, "ModuleInstantiation"),
            RefNode::ParameterValueAssignment(_) => write!(f, "ParameterValueAssignment"),
            RefNode::ListOfParameterAssignments(_) => write!(f, "ListOfParameterAssignments"),
            RefNode::ListOfParameterAssignmentsOrdered(_) => write!(f, "ListOfParameterAssignmentsOrdered"),
            RefNode::ListOfParameterAssignmentsNamed(_) => write!(f, "ListOfParameterAssignmentsNamed"),
            RefNode::OrderedParameterAssignment(_) => write!(f, "OrderedParameterAssignment"),
            RefNode::NamedParameterAssignment(_) => write!(f, "NamedParameterAssignment"),
            RefNode::HierarchicalInstance(_) => write!(f, "HierarchicalInstance"),
            RefNode::NameOfInstance(_) => write!(f, "NameOfInstance"),
            RefNode::ListOfPortConnections(_) => write!(f, "ListOfPortConnections"),
            RefNode::ListOfPortConnectionsOrdered(_) => write!(f, "ListOfPortConnectionsOrdered"),
            RefNode::ListOfPortConnectionsNamed(_) => write!(f, "ListOfPortConnectionsNamed"),
            RefNode::OrderedPortConnection(_) => write!(f, "OrderedPortConnection"),
            RefNode::NamedPortConnection(_) => write!(f, "NamedPortConnection"),
            RefNode::NamedPortConnectionIdentifier(_) => write!(f, "NamedPortConnectionIdentifier"),
            RefNode::NamedPortConnectionAsterisk(_) => write!(f, "NamedPortConnectionAsterisk"),
            RefNode::ProgramInstantiation(_) => write!(f, "ProgramInstantiation"),
            RefNode::GenerateRegion(_) => write!(f, "GenerateRegion"),
            RefNode::LoopGenerateConstruct(_) => write!(f, "LoopGenerateConstruct"),
            RefNode::GenvarInitialization(_) => write!(f, "GenvarInitialization"),
            RefNode::Genvar(_) => write!(f, "Genvar"),
            RefNode::GenvarIteration(_) => write!(f, "GenvarIteration"),
            RefNode::GenvarIterationAssignment(_) => write!(f, "GenvarIterationAssignment"),
            RefNode::GenvarIterationPrefix(_) => write!(f, "GenvarIterationPrefix"),
            RefNode::GenvarIterationSuffix(_) => write!(f, "GenvarIterationSuffix"),
            RefNode::ConditionalGenerateConstruct(_) => write!(f, "ConditionalGenerateConstruct"),
            RefNode::IfGenerateConstruct(_) => write!(f, "IfGenerateConstruct"),
            RefNode::CaseGenerateConstruct(_) => write!(f, "CaseGenerateConstruct"),
            RefNode::CaseGenerateItem(_) => write!(f, "CaseGenerateItem"),
            RefNode::CaseGenerateItemNondefault(_) => write!(f, "CaseGenerateItemNondefault"),
            RefNode::CaseGenerateItemDefault(_) => write!(f, "CaseGenerateItemDefault"),
            RefNode::GenerateBlock(_) => write!(f, "GenerateBlock"),
            RefNode::GenerateBlockMultiple(_) => write!(f, "GenerateBlockMultiple"),
            RefNode::GenerateItem(_) => write!(f, "GenerateItem"),

        }
    }
}


impl std::fmt::Display for AnyNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AnyNode::Locate(_) => write!(f, "Locate"),
            AnyNode::ArrayIdentifier(_) => write!(f, "ArrayIdentifier"),
            AnyNode::BlockIdentifier(_) => write!(f, "BlockIdentifier"),
            AnyNode::BinIdentifier(_) => write!(f, "BinIdentifier"),
            AnyNode::CIdentifier(_) => write!(f, "CIdentifier"),
            AnyNode::CellIdentifier(_) => write!(f, "CellIdentifier"),
            AnyNode::CheckerIdentifier(_) => write!(f, "CheckerIdentifier"),
            AnyNode::ClassIdentifier(_) => write!(f, "ClassIdentifier"),
            AnyNode::ClassVariableIdentifier(_) => write!(f, "ClassVariableIdentifier"),
            AnyNode::ClockingIdentifier(_) => write!(f, "ClockingIdentifier"),
            AnyNode::ConfigIdentifier(_) => write!(f, "ConfigIdentifier"),
            AnyNode::ConstIdentifier(_) => write!(f, "ConstIdentifier"),
            AnyNode::ConstraintIdentifier(_) => write!(f, "ConstraintIdentifier"),
            AnyNode::CovergroupIdentifier(_) => write!(f, "CovergroupIdentifier"),
            AnyNode::CovergroupVariableIdentifier(_) => write!(f, "CovergroupVariableIdentifier"),
            AnyNode::CoverPointIdentifier(_) => write!(f, "CoverPointIdentifier"),
            AnyNode::CrossIdentifier(_) => write!(f, "CrossIdentifier"),
            AnyNode::DynamicArrayVariableIdentifier(_) => write!(f, "DynamicArrayVariableIdentifier"),
            AnyNode::EnumIdentifier(_) => write!(f, "EnumIdentifier"),
            AnyNode::EscapedIdentifier(_) => write!(f, "EscapedIdentifier"),
            AnyNode::FormalIdentifier(_) => write!(f, "FormalIdentifier"),
            AnyNode::FormalPortIdentifier(_) => write!(f, "FormalPortIdentifier"),
            AnyNode::FunctionIdentifier(_) => write!(f, "FunctionIdentifier"),
            AnyNode::GenerateBlockIdentifier(_) => write!(f, "GenerateBlockIdentifier"),
            AnyNode::GenvarIdentifier(_) => write!(f, "GenvarIdentifier"),
            AnyNode::HierarchicalArrayIdentifier(_) => write!(f, "HierarchicalArrayIdentifier"),
            AnyNode::HierarchicalBlockIdentifier(_) => write!(f, "HierarchicalBlockIdentifier"),
            AnyNode::HierarchicalEventIdentifier(_) => write!(f, "HierarchicalEventIdentifier"),
            AnyNode::HierarchicalIdentifier(_) => write!(f, "HierarchicalIdentifier"),
            AnyNode::Root(_) => write!(f, "Root"),
            AnyNode::HierarchicalNetIdentifier(_) => write!(f, "HierarchicalNetIdentifier"),
            AnyNode::HierarchicalParameterIdentifier(_) => write!(f, "HierarchicalParameterIdentifier"),
            AnyNode::HierarchicalPropertyIdentifier(_) => write!(f, "HierarchicalPropertyIdentifier"),
            AnyNode::HierarchicalSequenceIdentifier(_) => write!(f, "HierarchicalSequenceIdentifier"),
            AnyNode::HierarchicalTaskIdentifier(_) => write!(f, "HierarchicalTaskIdentifier"),
            AnyNode::HierarchicalTfIdentifier(_) => write!(f, "HierarchicalTfIdentifier"),
            AnyNode::HierarchicalVariableIdentifier(_) => write!(f, "HierarchicalVariableIdentifier"),
            AnyNode::Identifier(_) => write!(f, "Identifier"),
            AnyNode::IndexVariableIdentifier(_) => write!(f, "IndexVariableIdentifier"),
            AnyNode::InterfaceIdentifier(_) => write!(f, "InterfaceIdentifier"),
            AnyNode::InterfaceInstanceIdentifier(_) => write!(f, "InterfaceInstanceIdentifier"),
            AnyNode::InoutPortIdentifier(_) => write!(f, "InoutPortIdentifier"),
            AnyNode::InputPortIdentifier(_) => write!(f, "InputPortIdentifier"),
            AnyNode::InstanceIdentifier(_) => write!(f, "InstanceIdentifier"),
            AnyNode::LibraryIdentifier(_) => write!(f, "LibraryIdentifier"),
            AnyNode::MemberIdentifier(_) => write!(f, "MemberIdentifier"),
            AnyNode::MethodIdentifier(_) => write!(f, "MethodIdentifier"),
            AnyNode::ModportIdentifier(_) => write!(f, "ModportIdentifier"),
            AnyNode::ModuleIdentifier(_) => write!(f, "ModuleIdentifier"),
            AnyNode::NetIdentifier(_) => write!(f, "NetIdentifier"),
            AnyNode::NetTypeIdentifier(_) => write!(f, "NetTypeIdentifier"),
            AnyNode::OutputPortIdentifier(_) => write!(f, "OutputPortIdentifier"),
            AnyNode::PackageIdentifier(_) => write!(f, "PackageIdentifier"),
            AnyNode::PackageScope(_) => write!(f, "PackageScope"),
            AnyNode::PackageScopePackage(_) => write!(f, "PackageScopePackage"),
            AnyNode::Unit(_) => write!(f, "Unit"),
            AnyNode::ParameterIdentifier(_) => write!(f, "ParameterIdentifier"),
            AnyNode::PortIdentifier(_) => write!(f, "PortIdentifier"),
            AnyNode::ProductionIdentifier(_) => write!(f, "ProductionIdentifier"),
            AnyNode::ProgramIdentifier(_) => write!(f, "ProgramIdentifier"),
            AnyNode::PropertyIdentifier(_) => write!(f, "PropertyIdentifier"),
            AnyNode::PsClassIdentifier(_) => write!(f, "PsClassIdentifier"),
            AnyNode::PsCovergroupIdentifier(_) => write!(f, "PsCovergroupIdentifier"),
            AnyNode::PsCheckerIdentifier(_) => write!(f, "PsCheckerIdentifier"),
            AnyNode::PsIdentifier(_) => write!(f, "PsIdentifier"),
            AnyNode::PsOrHierarchicalArrayIdentifier(_) => write!(f, "PsOrHierarchicalArrayIdentifier"),
            AnyNode::PsOrHierarchicalNetIdentifier(_) => write!(f, "PsOrHierarchicalNetIdentifier"),
            AnyNode::PsOrHierarchicalNetIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalNetIdentifierPackageScope"),
            AnyNode::PsOrHierarchicalNetIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalNetIdentifierHierarchical"),
            AnyNode::PsOrHierarchicalPropertyIdentifier(_) => write!(f, "PsOrHierarchicalPropertyIdentifier"),
            AnyNode::PsOrHierarchicalPropertyIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalPropertyIdentifierPackageScope"),
            AnyNode::PsOrHierarchicalPropertyIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalPropertyIdentifierHierarchical"),
            AnyNode::PsOrHierarchicalSequenceIdentifier(_) => write!(f, "PsOrHierarchicalSequenceIdentifier"),
            AnyNode::PsOrHierarchicalSequenceIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalSequenceIdentifierPackageScope"),
            AnyNode::PsOrHierarchicalSequenceIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalSequenceIdentifierHierarchical"),
            AnyNode::PsOrHierarchicalTfIdentifier(_) => write!(f, "PsOrHierarchicalTfIdentifier"),
            AnyNode::PsOrHierarchicalTfIdentifierPackageScope(_) => write!(f, "PsOrHierarchicalTfIdentifierPackageScope"),
            AnyNode::PsOrHierarchicalTfIdentifierHierarchical(_) => write!(f, "PsOrHierarchicalTfIdentifierHierarchical"),
            AnyNode::PsParameterIdentifier(_) => write!(f, "PsParameterIdentifier"),
            AnyNode::PsParameterIdentifierScope(_) => write!(f, "PsParameterIdentifierScope"),
            AnyNode::PsParameterIdentifierGenerate(_) => write!(f, "PsParameterIdentifierGenerate"),
            AnyNode::PsTypeIdentifier(_) => write!(f, "PsTypeIdentifier"),
            AnyNode::LocalOrPackageScopeOrClassScope(_) => write!(f, "LocalOrPackageScopeOrClassScope"),
            AnyNode::Local(_) => write!(f, "Local"),
            AnyNode::SequenceIdentifier(_) => write!(f, "SequenceIdentifier"),
            AnyNode::SignalIdentifier(_) => write!(f, "SignalIdentifier"),
            AnyNode::SimpleIdentifier(_) => write!(f, "SimpleIdentifier"),
            AnyNode::SpecparamIdentifier(_) => write!(f, "SpecparamIdentifier"),
            AnyNode::SystemTfIdentifier(_) => write!(f, "SystemTfIdentifier"),
            AnyNode::TaskIdentifier(_) => write!(f, "TaskIdentifier"),
            AnyNode::TfIdentifier(_) => write!(f, "TfIdentifier"),
            AnyNode::TerminalIdentifier(_) => write!(f, "TerminalIdentifier"),
            AnyNode::TopmoduleIdentifier(_) => write!(f, "TopmoduleIdentifier"),
            AnyNode::TypeIdentifier(_) => write!(f, "TypeIdentifier"),
            AnyNode::UdpIdentifier(_) => write!(f, "UdpIdentifier"),
            AnyNode::VariableIdentifier(_) => write!(f, "VariableIdentifier"),
            AnyNode::ImplicitClassHandleOrClassScopeOrPackageScope(_) => write!(f, "ImplicitClassHandleOrClassScopeOrPackageScope"),
            AnyNode::ImplicitClassHandleOrPackageScope(_) => write!(f, "ImplicitClassHandleOrPackageScope"),
            AnyNode::ImplicitClassHandleOrClassScope(_) => write!(f, "ImplicitClassHandleOrClassScope"),
            AnyNode::PackageScopeOrClassScope(_) => write!(f, "PackageScopeOrClassScope"),
            AnyNode::CompilerDirective(_) => write!(f, "CompilerDirective"),
            AnyNode::ResetallCompilerDirective(_) => write!(f, "ResetallCompilerDirective"),
            AnyNode::IncludeCompilerDirective(_) => write!(f, "IncludeCompilerDirective"),
            AnyNode::IncludeCompilerDirectiveDoubleQuote(_) => write!(f, "IncludeCompilerDirectiveDoubleQuote"),
            AnyNode::IncludeCompilerDirectiveAngleBracket(_) => write!(f, "IncludeCompilerDirectiveAngleBracket"),
            AnyNode::IncludeCompilerDirectiveTextMacroUsage(_) => write!(f, "IncludeCompilerDirectiveTextMacroUsage"),
            AnyNode::AngleBracketLiteral(_) => write!(f, "AngleBracketLiteral"),
            AnyNode::TextMacroDefinition(_) => write!(f, "TextMacroDefinition"),
            AnyNode::TextMacroName(_) => write!(f, "TextMacroName"),
            AnyNode::ListOfFormalArguments(_) => write!(f, "ListOfFormalArguments"),
            AnyNode::FormalArgument(_) => write!(f, "FormalArgument"),
            AnyNode::TextMacroIdentifier(_) => write!(f, "TextMacroIdentifier"),
            AnyNode::MacroText(_) => write!(f, "MacroText"),
            AnyNode::DefaultText(_) => write!(f, "DefaultText"),
            AnyNode::TextMacroUsage(_) => write!(f, "TextMacroUsage"),
            AnyNode::ListOfActualArguments(_) => write!(f, "ListOfActualArguments"),
            AnyNode::ActualArgument(_) => write!(f, "ActualArgument"),
            AnyNode::UndefineCompilerDirective(_) => write!(f, "UndefineCompilerDirective"),
            AnyNode::UndefineallCompilerDirective(_) => write!(f, "UndefineallCompilerDirective"),
            AnyNode::ConditionalCompilerDirective(_) => write!(f, "ConditionalCompilerDirective"),
            AnyNode::IfdefDirective(_) => write!(f, "IfdefDirective"),
            AnyNode::IfndefDirective(_) => write!(f, "IfndefDirective"),
            AnyNode::IfdefGroupOfLines(_) => write!(f, "IfdefGroupOfLines"),
            AnyNode::IfndefGroupOfLines(_) => write!(f, "IfndefGroupOfLines"),
            AnyNode::ElsifGroupOfLines(_) => write!(f, "ElsifGroupOfLines"),
            AnyNode::ElseGroupOfLines(_) => write!(f, "ElseGroupOfLines"),
            AnyNode::SourceDescription(_) => write!(f, "SourceDescription"),
            AnyNode::SourceDescriptionNotDirective(_) => write!(f, "SourceDescriptionNotDirective"),
            AnyNode::TimescaleCompilerDirective(_) => write!(f, "TimescaleCompilerDirective"),
            AnyNode::DefaultNettypeCompilerDirective(_) => write!(f, "DefaultNettypeCompilerDirective"),
            AnyNode::DefaultNettypeValue(_) => write!(f, "DefaultNettypeValue"),
            AnyNode::UnconnectedDriveCompilerDirective(_) => write!(f, "UnconnectedDriveCompilerDirective"),
            AnyNode::NounconnectedDriveCompilerDirective(_) => write!(f, "NounconnectedDriveCompilerDirective"),
            AnyNode::CelldefineDriveCompilerDirective(_) => write!(f, "CelldefineDriveCompilerDirective"),
            AnyNode::EndcelldefineDriveCompilerDirective(_) => write!(f, "EndcelldefineDriveCompilerDirective"),
            AnyNode::Pragma(_) => write!(f, "Pragma"),
            AnyNode::PragmaName(_) => write!(f, "PragmaName"),
            AnyNode::PragmaExpression(_) => write!(f, "PragmaExpression"),
            AnyNode::PragmaExpressionAssignment(_) => write!(f, "PragmaExpressionAssignment"),
            AnyNode::PragmaValue(_) => write!(f, "PragmaValue"),
            AnyNode::PragmaValueParen(_) => write!(f, "PragmaValueParen"),
            AnyNode::PragmaKeyword(_) => write!(f, "PragmaKeyword"),
            AnyNode::LineCompilerDirective(_) => write!(f, "LineCompilerDirective"),
            AnyNode::PositionCompilerDirective(_) => write!(f, "PositionCompilerDirective"),
            AnyNode::Level(_) => write!(f, "Level"),
            AnyNode::KeywordsDirective(_) => write!(f, "KeywordsDirective"),
            AnyNode::VersionSpecifier(_) => write!(f, "VersionSpecifier"),
            AnyNode::EndkeywordsDirective(_) => write!(f, "EndkeywordsDirective"),
            AnyNode::Comment(_) => write!(f, "Comment"),
            AnyNode::AttributeInstance(_) => write!(f, "AttributeInstance"),
            AnyNode::AttrSpec(_) => write!(f, "AttrSpec"),
            AnyNode::SourceText(_) => write!(f, "SourceText"),
            AnyNode::Description(_) => write!(f, "Description"),
            AnyNode::DescriptionPackageItem(_) => write!(f, "DescriptionPackageItem"),
            AnyNode::DescriptionBindDirective(_) => write!(f, "DescriptionBindDirective"),
            AnyNode::ModuleNonansiHeader(_) => write!(f, "ModuleNonansiHeader"),
            AnyNode::ModuleAnsiHeader(_) => write!(f, "ModuleAnsiHeader"),
            AnyNode::ModuleDeclaration(_) => write!(f, "ModuleDeclaration"),
            AnyNode::ModuleDeclarationNonansi(_) => write!(f, "ModuleDeclarationNonansi"),
            AnyNode::ModuleDeclarationAnsi(_) => write!(f, "ModuleDeclarationAnsi"),
            AnyNode::ModuleDeclarationWildcard(_) => write!(f, "ModuleDeclarationWildcard"),
            AnyNode::ModuleDeclarationExternNonansi(_) => write!(f, "ModuleDeclarationExternNonansi"),
            AnyNode::ModuleDeclarationExternAnsi(_) => write!(f, "ModuleDeclarationExternAnsi"),
            AnyNode::ModuleKeyword(_) => write!(f, "ModuleKeyword"),
            AnyNode::InterfaceDeclaration(_) => write!(f, "InterfaceDeclaration"),
            AnyNode::InterfaceDeclarationNonansi(_) => write!(f, "InterfaceDeclarationNonansi"),
            AnyNode::InterfaceDeclarationAnsi(_) => write!(f, "InterfaceDeclarationAnsi"),
            AnyNode::InterfaceDeclarationWildcard(_) => write!(f, "InterfaceDeclarationWildcard"),
            AnyNode::InterfaceDeclarationExternNonansi(_) => write!(f, "InterfaceDeclarationExternNonansi"),
            AnyNode::InterfaceDeclarationExternAnsi(_) => write!(f, "InterfaceDeclarationExternAnsi"),
            AnyNode::InterfaceNonansiHeader(_) => write!(f, "InterfaceNonansiHeader"),
            AnyNode::InterfaceAnsiHeader(_) => write!(f, "InterfaceAnsiHeader"),
            AnyNode::ProgramDeclaration(_) => write!(f, "ProgramDeclaration"),
            AnyNode::ProgramDeclarationNonansi(_) => write!(f, "ProgramDeclarationNonansi"),
            AnyNode::ProgramDeclarationAnsi(_) => write!(f, "ProgramDeclarationAnsi"),
            AnyNode::ProgramDeclarationWildcard(_) => write!(f, "ProgramDeclarationWildcard"),
            AnyNode::ProgramDeclarationExternNonansi(_) => write!(f, "ProgramDeclarationExternNonansi"),
            AnyNode::ProgramDeclarationExternAnsi(_) => write!(f, "ProgramDeclarationExternAnsi"),
            AnyNode::ProgramNonansiHeader(_) => write!(f, "ProgramNonansiHeader"),
            AnyNode::ProgramAnsiHeader(_) => write!(f, "ProgramAnsiHeader"),
            AnyNode::CheckerDeclaration(_) => write!(f, "CheckerDeclaration"),
            AnyNode::ClassDeclaration(_) => write!(f, "ClassDeclaration"),
            AnyNode::Virtual(_) => write!(f, "Virtual"),
            AnyNode::InterfaceClassType(_) => write!(f, "InterfaceClassType"),
            AnyNode::InterfaceClassDeclaration(_) => write!(f, "InterfaceClassDeclaration"),
            AnyNode::InterfaceClassItem(_) => write!(f, "InterfaceClassItem"),
            AnyNode::InterfaceClassItemMethod(_) => write!(f, "InterfaceClassItemMethod"),
            AnyNode::InterfaceClassMethod(_) => write!(f, "InterfaceClassMethod"),
            AnyNode::PackageDeclaration(_) => write!(f, "PackageDeclaration"),
            AnyNode::TimeunitsDeclaration(_) => write!(f, "TimeunitsDeclaration"),
            AnyNode::TimeunitsDeclarationTimeunit(_) => write!(f, "TimeunitsDeclarationTimeunit"),
            AnyNode::TimeunitsDeclarationTimeprecision(_) => write!(f, "TimeunitsDeclarationTimeprecision"),
            AnyNode::TimeunitsDeclarationTimeunitTimeprecision(_) => write!(f, "TimeunitsDeclarationTimeunitTimeprecision"),
            AnyNode::TimeunitsDeclarationTimeprecisionTimeunit(_) => write!(f, "TimeunitsDeclarationTimeprecisionTimeunit"),
            AnyNode::PackageItem(_) => write!(f, "PackageItem"),
            AnyNode::PackageOrGenerateItemDeclaration(_) => write!(f, "PackageOrGenerateItemDeclaration"),
            AnyNode::AnonymousProgram(_) => write!(f, "AnonymousProgram"),
            AnyNode::AnonymousProgramItem(_) => write!(f, "AnonymousProgramItem"),
            AnyNode::ElaborationSystemTask(_) => write!(f, "ElaborationSystemTask"),
            AnyNode::ElaborationSystemTaskFatal(_) => write!(f, "ElaborationSystemTaskFatal"),
            AnyNode::ElaborationSystemTaskError(_) => write!(f, "ElaborationSystemTaskError"),
            AnyNode::ElaborationSystemTaskWarning(_) => write!(f, "ElaborationSystemTaskWarning"),
            AnyNode::ElaborationSystemTaskInfo(_) => write!(f, "ElaborationSystemTaskInfo"),
            AnyNode::FinishNumber(_) => write!(f, "FinishNumber"),
            AnyNode::ModuleCommonItem(_) => write!(f, "ModuleCommonItem"),
            AnyNode::ModuleItem(_) => write!(f, "ModuleItem"),
            AnyNode::ModuleOrGenerateItem(_) => write!(f, "ModuleOrGenerateItem"),
            AnyNode::ModuleOrGenerateItemParameter(_) => write!(f, "ModuleOrGenerateItemParameter"),
            AnyNode::ModuleOrGenerateItemGate(_) => write!(f, "ModuleOrGenerateItemGate"),
            AnyNode::ModuleOrGenerateItemUdp(_) => write!(f, "ModuleOrGenerateItemUdp"),
            AnyNode::ModuleOrGenerateItemModule(_) => write!(f, "ModuleOrGenerateItemModule"),
            AnyNode::ModuleOrGenerateItemModuleItem(_) => write!(f, "ModuleOrGenerateItemModuleItem"),
            AnyNode::ModuleOrGenerateItemDeclaration(_) => write!(f, "ModuleOrGenerateItemDeclaration"),
            AnyNode::ModuleOrGenerateItemDeclarationClocking(_) => write!(f, "ModuleOrGenerateItemDeclarationClocking"),
            AnyNode::ModuleOrGenerateItemDeclarationDisable(_) => write!(f, "ModuleOrGenerateItemDeclarationDisable"),
            AnyNode::NonPortModuleItem(_) => write!(f, "NonPortModuleItem"),
            AnyNode::NonPortModuleItemSpecparam(_) => write!(f, "NonPortModuleItemSpecparam"),
            AnyNode::ParameterOverride(_) => write!(f, "ParameterOverride"),
            AnyNode::BindDirective(_) => write!(f, "BindDirective"),
            AnyNode::BindDirectiveScope(_) => write!(f, "BindDirectiveScope"),
            AnyNode::BindDirectiveInstance(_) => write!(f, "BindDirectiveInstance"),
            AnyNode::BindTargetScope(_) => write!(f, "BindTargetScope"),
            AnyNode::BindTargetInstance(_) => write!(f, "BindTargetInstance"),
            AnyNode::BindTargetInstanceList(_) => write!(f, "BindTargetInstanceList"),
            AnyNode::BindInstantiation(_) => write!(f, "BindInstantiation"),
            AnyNode::ParameterPortList(_) => write!(f, "ParameterPortList"),
            AnyNode::ParameterPortListAssignment(_) => write!(f, "ParameterPortListAssignment"),
            AnyNode::ParameterPortListDeclaration(_) => write!(f, "ParameterPortListDeclaration"),
            AnyNode::ParameterPortDeclaration(_) => write!(f, "ParameterPortDeclaration"),
            AnyNode::ParameterPortDeclarationParamList(_) => write!(f, "ParameterPortDeclarationParamList"),
            AnyNode::ParameterPortDeclarationTypeList(_) => write!(f, "ParameterPortDeclarationTypeList"),
            AnyNode::ListOfPorts(_) => write!(f, "ListOfPorts"),
            AnyNode::ListOfPortDeclarations(_) => write!(f, "ListOfPortDeclarations"),
            AnyNode::PortDeclaration(_) => write!(f, "PortDeclaration"),
            AnyNode::PortDeclarationInout(_) => write!(f, "PortDeclarationInout"),
            AnyNode::PortDeclarationInput(_) => write!(f, "PortDeclarationInput"),
            AnyNode::PortDeclarationOutput(_) => write!(f, "PortDeclarationOutput"),
            AnyNode::PortDeclarationRef(_) => write!(f, "PortDeclarationRef"),
            AnyNode::PortDeclarationInterface(_) => write!(f, "PortDeclarationInterface"),
            AnyNode::Port(_) => write!(f, "Port"),
            AnyNode::PortNonNamed(_) => write!(f, "PortNonNamed"),
            AnyNode::PortNamed(_) => write!(f, "PortNamed"),
            AnyNode::PortExpression(_) => write!(f, "PortExpression"),
            AnyNode::PortExpressionBrace(_) => write!(f, "PortExpressionBrace"),
            AnyNode::PortReference(_) => write!(f, "PortReference"),
            AnyNode::PortDirection(_) => write!(f, "PortDirection"),
            AnyNode::NetPortHeader(_) => write!(f, "NetPortHeader"),
            AnyNode::VariablePortHeader(_) => write!(f, "VariablePortHeader"),
            AnyNode::InterfacePortHeader(_) => write!(f, "InterfacePortHeader"),
            AnyNode::InterfacePortHeaderIdentifier(_) => write!(f, "InterfacePortHeaderIdentifier"),
            AnyNode::InterfacePortHeaderInterface(_) => write!(f, "InterfacePortHeaderInterface"),
            AnyNode::NetPortHeaderOrInterfacePortHeader(_) => write!(f, "NetPortHeaderOrInterfacePortHeader"),
            AnyNode::AnsiPortDeclaration(_) => write!(f, "AnsiPortDeclaration"),
            AnyNode::AnsiPortDeclarationNet(_) => write!(f, "AnsiPortDeclarationNet"),
            AnyNode::AnsiPortDeclarationVariable(_) => write!(f, "AnsiPortDeclarationVariable"),
            AnyNode::AnsiPortDeclarationParen(_) => write!(f, "AnsiPortDeclarationParen"),
            AnyNode::CheckerPortList(_) => write!(f, "CheckerPortList"),
            AnyNode::CheckerPortItem(_) => write!(f, "CheckerPortItem"),
            AnyNode::CheckerPortDirection(_) => write!(f, "CheckerPortDirection"),
            AnyNode::CheckerOrGenerateItem(_) => write!(f, "CheckerOrGenerateItem"),
            AnyNode::CheckerOrGenerateItemDeclaration(_) => write!(f, "CheckerOrGenerateItemDeclaration"),
            AnyNode::CheckerOrGenerateItemDeclarationData(_) => write!(f, "CheckerOrGenerateItemDeclarationData"),
            AnyNode::Rand(_) => write!(f, "Rand"),
            AnyNode::CheckerOrGenerateItemDeclarationClocking(_) => write!(f, "CheckerOrGenerateItemDeclarationClocking"),
            AnyNode::CheckerOrGenerateItemDeclarationDisable(_) => write!(f, "CheckerOrGenerateItemDeclarationDisable"),
            AnyNode::CheckerGenerateItem(_) => write!(f, "CheckerGenerateItem"),
            AnyNode::ConstraintDeclaration(_) => write!(f, "ConstraintDeclaration"),
            AnyNode::Static(_) => write!(f, "Static"),
            AnyNode::ConstraintBlock(_) => write!(f, "ConstraintBlock"),
            AnyNode::ConstraintBlockItem(_) => write!(f, "ConstraintBlockItem"),
            AnyNode::ConstraintBlockItemSolve(_) => write!(f, "ConstraintBlockItemSolve"),
            AnyNode::SolveBeforeList(_) => write!(f, "SolveBeforeList"),
            AnyNode::ConstraintPrimary(_) => write!(f, "ConstraintPrimary"),
            AnyNode::ConstraintExpression(_) => write!(f, "ConstraintExpression"),
            AnyNode::ConstraintExpressionExpression(_) => write!(f, "ConstraintExpressionExpression"),
            AnyNode::Soft(_) => write!(f, "Soft"),
            AnyNode::ConstraintExpressionArrow(_) => write!(f, "ConstraintExpressionArrow"),
            AnyNode::ConstraintExpressionIf(_) => write!(f, "ConstraintExpressionIf"),
            AnyNode::ConstraintExpressionForeach(_) => write!(f, "ConstraintExpressionForeach"),
            AnyNode::ConstraintExpressionDisable(_) => write!(f, "ConstraintExpressionDisable"),
            AnyNode::UniquenessConstraint(_) => write!(f, "UniquenessConstraint"),
            AnyNode::ConstraintSet(_) => write!(f, "ConstraintSet"),
            AnyNode::ConstraintSetBrace(_) => write!(f, "ConstraintSetBrace"),
            AnyNode::DistList(_) => write!(f, "DistList"),
            AnyNode::DistItem(_) => write!(f, "DistItem"),
            AnyNode::DistWeight(_) => write!(f, "DistWeight"),
            AnyNode::DistWeightEqual(_) => write!(f, "DistWeightEqual"),
            AnyNode::DistWeightDivide(_) => write!(f, "DistWeightDivide"),
            AnyNode::ConstraintPrototype(_) => write!(f, "ConstraintPrototype"),
            AnyNode::ConstraintPrototypeQualifier(_) => write!(f, "ConstraintPrototypeQualifier"),
            AnyNode::ExternConstraintDeclaration(_) => write!(f, "ExternConstraintDeclaration"),
            AnyNode::IdentifierList(_) => write!(f, "IdentifierList"),
            AnyNode::InterfaceOrGenerateItem(_) => write!(f, "InterfaceOrGenerateItem"),
            AnyNode::InterfaceOrGenerateItemModule(_) => write!(f, "InterfaceOrGenerateItemModule"),
            AnyNode::InterfaceOrGenerateItemExtern(_) => write!(f, "InterfaceOrGenerateItemExtern"),
            AnyNode::ExternTfDeclaration(_) => write!(f, "ExternTfDeclaration"),
            AnyNode::ExternTfDeclarationMethod(_) => write!(f, "ExternTfDeclarationMethod"),
            AnyNode::ExternTfDeclarationTask(_) => write!(f, "ExternTfDeclarationTask"),
            AnyNode::InterfaceItem(_) => write!(f, "InterfaceItem"),
            AnyNode::NonPortInterfaceItem(_) => write!(f, "NonPortInterfaceItem"),
            AnyNode::ProgramItem(_) => write!(f, "ProgramItem"),
            AnyNode::NonPortProgramItem(_) => write!(f, "NonPortProgramItem"),
            AnyNode::NonPortProgramItemAssign(_) => write!(f, "NonPortProgramItemAssign"),
            AnyNode::NonPortProgramItemModule(_) => write!(f, "NonPortProgramItemModule"),
            AnyNode::NonPortProgramItemInitial(_) => write!(f, "NonPortProgramItemInitial"),
            AnyNode::NonPortProgramItemFinal(_) => write!(f, "NonPortProgramItemFinal"),
            AnyNode::NonPortProgramItemAssertion(_) => write!(f, "NonPortProgramItemAssertion"),
            AnyNode::ProgramGenerateItem(_) => write!(f, "ProgramGenerateItem"),
            AnyNode::LibraryText(_) => write!(f, "LibraryText"),
            AnyNode::LibraryDescription(_) => write!(f, "LibraryDescription"),
            AnyNode::LibraryDeclaration(_) => write!(f, "LibraryDeclaration"),
            AnyNode::IncludeStatement(_) => write!(f, "IncludeStatement"),
            AnyNode::FilePathSpec(_) => write!(f, "FilePathSpec"),
            AnyNode::FilePathSpecNonLiteral(_) => write!(f, "FilePathSpecNonLiteral"),
            AnyNode::ConfigDeclaration(_) => write!(f, "ConfigDeclaration"),
            AnyNode::DesignStatement(_) => write!(f, "DesignStatement"),
            AnyNode::ConfigRuleStatement(_) => write!(f, "ConfigRuleStatement"),
            AnyNode::ConfigRuleStatementDefault(_) => write!(f, "ConfigRuleStatementDefault"),
            AnyNode::ConfigRuleStatementInstLib(_) => write!(f, "ConfigRuleStatementInstLib"),
            AnyNode::ConfigRuleStatementInstUse(_) => write!(f, "ConfigRuleStatementInstUse"),
            AnyNode::ConfigRuleStatementCellLib(_) => write!(f, "ConfigRuleStatementCellLib"),
            AnyNode::ConfigRuleStatementCellUse(_) => write!(f, "ConfigRuleStatementCellUse"),
            AnyNode::DefaultClause(_) => write!(f, "DefaultClause"),
            AnyNode::InstClause(_) => write!(f, "InstClause"),
            AnyNode::InstName(_) => write!(f, "InstName"),
            AnyNode::CellClause(_) => write!(f, "CellClause"),
            AnyNode::LiblistClause(_) => write!(f, "LiblistClause"),
            AnyNode::UseClause(_) => write!(f, "UseClause"),
            AnyNode::UseClauseCell(_) => write!(f, "UseClauseCell"),
            AnyNode::UseClauseNamed(_) => write!(f, "UseClauseNamed"),
            AnyNode::UseClauseCellNamed(_) => write!(f, "UseClauseCellNamed"),
            AnyNode::Config(_) => write!(f, "Config"),
            AnyNode::ClassItem(_) => write!(f, "ClassItem"),
            AnyNode::ClassItemProperty(_) => write!(f, "ClassItemProperty"),
            AnyNode::ClassItemMethod(_) => write!(f, "ClassItemMethod"),
            AnyNode::ClassItemConstraint(_) => write!(f, "ClassItemConstraint"),
            AnyNode::ClassItemDeclaration(_) => write!(f, "ClassItemDeclaration"),
            AnyNode::ClassItemCovergroup(_) => write!(f, "ClassItemCovergroup"),
            AnyNode::ClassProperty(_) => write!(f, "ClassProperty"),
            AnyNode::ClassPropertyNonConst(_) => write!(f, "ClassPropertyNonConst"),
            AnyNode::ClassPropertyConst(_) => write!(f, "ClassPropertyConst"),
            AnyNode::ClassPropertyConstExpression(_) => write!(f, "ClassPropertyConstExpression"),
            AnyNode::ClassMethod(_) => write!(f, "ClassMethod"),
            AnyNode::ClassMethodTask(_) => write!(f, "ClassMethodTask"),
            AnyNode::ClassMethodFunction(_) => write!(f, "ClassMethodFunction"),
            AnyNode::ClassMethodPureVirtual(_) => write!(f, "ClassMethodPureVirtual"),
            AnyNode::ClassMethodExternMethod(_) => write!(f, "ClassMethodExternMethod"),
            AnyNode::ClassMethodConstructor(_) => write!(f, "ClassMethodConstructor"),
            AnyNode::ClassMethodExternConstructor(_) => write!(f, "ClassMethodExternConstructor"),
            AnyNode::ClassConstructorPrototype(_) => write!(f, "ClassConstructorPrototype"),
            AnyNode::ClassConstraint(_) => write!(f, "ClassConstraint"),
            AnyNode::ClassItemQualifier(_) => write!(f, "ClassItemQualifier"),
            AnyNode::PropertyQualifier(_) => write!(f, "PropertyQualifier"),
            AnyNode::RandomQualifier(_) => write!(f, "RandomQualifier"),
            AnyNode::MethodQualifier(_) => write!(f, "MethodQualifier"),
            AnyNode::MethodPrototype(_) => write!(f, "MethodPrototype"),
            AnyNode::ClassConstructorDeclaration(_) => write!(f, "ClassConstructorDeclaration"),
            AnyNode::New(_) => write!(f, "New"),
            AnyNode::Number(_) => write!(f, "Number"),
            AnyNode::IntegralNumber(_) => write!(f, "IntegralNumber"),
            AnyNode::DecimalNumber(_) => write!(f, "DecimalNumber"),
            AnyNode::DecimalNumberBaseUnsigned(_) => write!(f, "DecimalNumberBaseUnsigned"),
            AnyNode::DecimalNumberBaseXNumber(_) => write!(f, "DecimalNumberBaseXNumber"),
            AnyNode::DecimalNumberBaseZNumber(_) => write!(f, "DecimalNumberBaseZNumber"),
            AnyNode::BinaryNumber(_) => write!(f, "BinaryNumber"),
            AnyNode::OctalNumber(_) => write!(f, "OctalNumber"),
            AnyNode::HexNumber(_) => write!(f, "HexNumber"),
            AnyNode::Sign(_) => write!(f, "Sign"),
            AnyNode::Size(_) => write!(f, "Size"),
            AnyNode::NonZeroUnsignedNumber(_) => write!(f, "NonZeroUnsignedNumber"),
            AnyNode::RealNumber(_) => write!(f, "RealNumber"),
            AnyNode::RealNumberFloating(_) => write!(f, "RealNumberFloating"),
            AnyNode::FixedPointNumber(_) => write!(f, "FixedPointNumber"),
            AnyNode::Exp(_) => write!(f, "Exp"),
            AnyNode::UnsignedNumber(_) => write!(f, "UnsignedNumber"),
            AnyNode::BinaryValue(_) => write!(f, "BinaryValue"),
            AnyNode::OctalValue(_) => write!(f, "OctalValue"),
            AnyNode::HexValue(_) => write!(f, "HexValue"),
            AnyNode::DecimalBase(_) => write!(f, "DecimalBase"),
            AnyNode::BinaryBase(_) => write!(f, "BinaryBase"),
            AnyNode::OctalBase(_) => write!(f, "OctalBase"),
            AnyNode::HexBase(_) => write!(f, "HexBase"),
            AnyNode::XNumber(_) => write!(f, "XNumber"),
            AnyNode::ZNumber(_) => write!(f, "ZNumber"),
            AnyNode::UnbasedUnsizedLiteral(_) => write!(f, "UnbasedUnsizedLiteral"),
            AnyNode::UnaryOperator(_) => write!(f, "UnaryOperator"),
            AnyNode::BinaryOperator(_) => write!(f, "BinaryOperator"),
            AnyNode::IncOrDecOperator(_) => write!(f, "IncOrDecOperator"),
            AnyNode::UnaryModulePathOperator(_) => write!(f, "UnaryModulePathOperator"),
            AnyNode::BinaryModulePathOperator(_) => write!(f, "BinaryModulePathOperator"),
            AnyNode::ConstantPrimary(_) => write!(f, "ConstantPrimary"),
            AnyNode::ConstantPrimaryPsParameter(_) => write!(f, "ConstantPrimaryPsParameter"),
            AnyNode::ConstantPrimarySpecparam(_) => write!(f, "ConstantPrimarySpecparam"),
            AnyNode::ConstantPrimaryFormalPort(_) => write!(f, "ConstantPrimaryFormalPort"),
            AnyNode::ConstantPrimaryEnum(_) => write!(f, "ConstantPrimaryEnum"),
            AnyNode::ConstantPrimaryConcatenation(_) => write!(f, "ConstantPrimaryConcatenation"),
            AnyNode::ConstantPrimaryMultipleConcatenation(_) => write!(f, "ConstantPrimaryMultipleConcatenation"),
            AnyNode::ConstantPrimaryMintypmaxExpression(_) => write!(f, "ConstantPrimaryMintypmaxExpression"),
            AnyNode::ModulePathPrimary(_) => write!(f, "ModulePathPrimary"),
            AnyNode::ModulePathPrimaryMintypmax(_) => write!(f, "ModulePathPrimaryMintypmax"),
            AnyNode::Primary(_) => write!(f, "Primary"),
            AnyNode::PrimaryHierarchical(_) => write!(f, "PrimaryHierarchical"),
            AnyNode::PrimaryConcatenation(_) => write!(f, "PrimaryConcatenation"),
            AnyNode::PrimaryMultipleConcatenation(_) => write!(f, "PrimaryMultipleConcatenation"),
            AnyNode::PrimaryMintypmaxExpression(_) => write!(f, "PrimaryMintypmaxExpression"),
            AnyNode::ClassQualifierOrPackageScope(_) => write!(f, "ClassQualifierOrPackageScope"),
            AnyNode::ClassQualifier(_) => write!(f, "ClassQualifier"),
            AnyNode::RangeExpression(_) => write!(f, "RangeExpression"),
            AnyNode::PrimaryLiteral(_) => write!(f, "PrimaryLiteral"),
            AnyNode::TimeLiteral(_) => write!(f, "TimeLiteral"),
            AnyNode::TimeLiteralUnsigned(_) => write!(f, "TimeLiteralUnsigned"),
            AnyNode::TimeLiteralFixedPoint(_) => write!(f, "TimeLiteralFixedPoint"),
            AnyNode::TimeUnit(_) => write!(f, "TimeUnit"),
            AnyNode::ImplicitClassHandle(_) => write!(f, "ImplicitClassHandle"),
            AnyNode::BitSelect(_) => write!(f, "BitSelect"),
            AnyNode::Select(_) => write!(f, "Select"),
            AnyNode::NonrangeSelect(_) => write!(f, "NonrangeSelect"),
            AnyNode::ConstantBitSelect(_) => write!(f, "ConstantBitSelect"),
            AnyNode::ConstantSelect(_) => write!(f, "ConstantSelect"),
            AnyNode::ConstantCast(_) => write!(f, "ConstantCast"),
            AnyNode::ConstantLetExpression(_) => write!(f, "ConstantLetExpression"),
            AnyNode::Cast(_) => write!(f, "Cast"),
            AnyNode::Concatenation(_) => write!(f, "Concatenation"),
            AnyNode::ConstantConcatenation(_) => write!(f, "ConstantConcatenation"),
            AnyNode::ConstantMultipleConcatenation(_) => write!(f, "ConstantMultipleConcatenation"),
            AnyNode::ModulePathConcatenation(_) => write!(f, "ModulePathConcatenation"),
            AnyNode::ModulePathMultipleConcatenation(_) => write!(f, "ModulePathMultipleConcatenation"),
            AnyNode::MultipleConcatenation(_) => write!(f, "MultipleConcatenation"),
            AnyNode::StreamingConcatenation(_) => write!(f, "StreamingConcatenation"),
            AnyNode::StreamOperator(_) => write!(f, "StreamOperator"),
            AnyNode::SliceSize(_) => write!(f, "SliceSize"),
            AnyNode::StreamConcatenation(_) => write!(f, "StreamConcatenation"),
            AnyNode::StreamExpression(_) => write!(f, "StreamExpression"),
            AnyNode::ArrayRangeExpression(_) => write!(f, "ArrayRangeExpression"),
            AnyNode::ArrayRangeExpressionColon(_) => write!(f, "ArrayRangeExpressionColon"),
            AnyNode::ArrayRangeExpressionPlusColon(_) => write!(f, "ArrayRangeExpressionPlusColon"),
            AnyNode::ArrayRangeExpressionMinusColon(_) => write!(f, "ArrayRangeExpressionMinusColon"),
            AnyNode::EmptyUnpackedArrayConcatenation(_) => write!(f, "EmptyUnpackedArrayConcatenation"),
            AnyNode::IncOrDecExpression(_) => write!(f, "IncOrDecExpression"),
            AnyNode::IncOrDecExpressionPrefix(_) => write!(f, "IncOrDecExpressionPrefix"),
            AnyNode::IncOrDecExpressionSuffix(_) => write!(f, "IncOrDecExpressionSuffix"),
            AnyNode::ConditionalExpression(_) => write!(f, "ConditionalExpression"),
            AnyNode::ConstantExpression(_) => write!(f, "ConstantExpression"),
            AnyNode::ConstantExpressionUnary(_) => write!(f, "ConstantExpressionUnary"),
            AnyNode::ConstantExpressionBinary(_) => write!(f, "ConstantExpressionBinary"),
            AnyNode::ConstantExpressionTernary(_) => write!(f, "ConstantExpressionTernary"),
            AnyNode::ConstantMintypmaxExpression(_) => write!(f, "ConstantMintypmaxExpression"),
            AnyNode::ConstantMintypmaxExpressionTernary(_) => write!(f, "ConstantMintypmaxExpressionTernary"),
            AnyNode::ConstantParamExpression(_) => write!(f, "ConstantParamExpression"),
            AnyNode::ParamExpression(_) => write!(f, "ParamExpression"),
            AnyNode::ConstantRangeExpression(_) => write!(f, "ConstantRangeExpression"),
            AnyNode::ConstantPartSelectRange(_) => write!(f, "ConstantPartSelectRange"),
            AnyNode::ConstantRange(_) => write!(f, "ConstantRange"),
            AnyNode::ConstantIndexedRange(_) => write!(f, "ConstantIndexedRange"),
            AnyNode::Expression(_) => write!(f, "Expression"),
            AnyNode::ExpressionUnary(_) => write!(f, "ExpressionUnary"),
            AnyNode::ExpressionOperatorAssignment(_) => write!(f, "ExpressionOperatorAssignment"),
            AnyNode::ExpressionBinary(_) => write!(f, "ExpressionBinary"),
            AnyNode::TaggedUnionExpression(_) => write!(f, "TaggedUnionExpression"),
            AnyNode::InsideExpression(_) => write!(f, "InsideExpression"),
            AnyNode::ValueRange(_) => write!(f, "ValueRange"),
            AnyNode::ValueRangeBinary(_) => write!(f, "ValueRangeBinary"),
            AnyNode::MintypmaxExpression(_) => write!(f, "MintypmaxExpression"),
            AnyNode::MintypmaxExpressionTernary(_) => write!(f, "MintypmaxExpressionTernary"),
            AnyNode::ModulePathConditionalExpression(_) => write!(f, "ModulePathConditionalExpression"),
            AnyNode::ModulePathExpression(_) => write!(f, "ModulePathExpression"),
            AnyNode::ModulePathExpressionUnary(_) => write!(f, "ModulePathExpressionUnary"),
            AnyNode::ModulePathExpressionBinary(_) => write!(f, "ModulePathExpressionBinary"),
            AnyNode::ModulePathMintypmaxExpression(_) => write!(f, "ModulePathMintypmaxExpression"),
            AnyNode::ModulePathMintypmaxExpressionTernary(_) => write!(f, "ModulePathMintypmaxExpressionTernary"),
            AnyNode::PartSelectRange(_) => write!(f, "PartSelectRange"),
            AnyNode::IndexedRange(_) => write!(f, "IndexedRange"),
            AnyNode::GenvarExpression(_) => write!(f, "GenvarExpression"),
            AnyNode::ConstantFunctionCall(_) => write!(f, "ConstantFunctionCall"),
            AnyNode::TfCall(_) => write!(f, "TfCall"),
            AnyNode::SystemTfCall(_) => write!(f, "SystemTfCall"),
            AnyNode::SystemTfCallArgOptional(_) => write!(f, "SystemTfCallArgOptional"),
            AnyNode::SystemTfCallArgDataType(_) => write!(f, "SystemTfCallArgDataType"),
            AnyNode::SystemTfCallArgExpression(_) => write!(f, "SystemTfCallArgExpression"),
            AnyNode::SubroutineCall(_) => write!(f, "SubroutineCall"),
            AnyNode::SubroutineCallRandomize(_) => write!(f, "SubroutineCallRandomize"),
            AnyNode::FunctionSubroutineCall(_) => write!(f, "FunctionSubroutineCall"),
            AnyNode::ListOfArguments(_) => write!(f, "ListOfArguments"),
            AnyNode::ListOfArgumentsOrdered(_) => write!(f, "ListOfArgumentsOrdered"),
            AnyNode::ListOfArgumentsNamed(_) => write!(f, "ListOfArgumentsNamed"),
            AnyNode::MethodCall(_) => write!(f, "MethodCall"),
            AnyNode::MethodCallBody(_) => write!(f, "MethodCallBody"),
            AnyNode::MethodCallBodyUser(_) => write!(f, "MethodCallBodyUser"),
            AnyNode::BuiltInMethodCall(_) => write!(f, "BuiltInMethodCall"),
            AnyNode::ArrayManipulationCall(_) => write!(f, "ArrayManipulationCall"),
            AnyNode::RandomizeCall(_) => write!(f, "RandomizeCall"),
            AnyNode::VariableIdentifierListOrNull(_) => write!(f, "VariableIdentifierListOrNull"),
            AnyNode::MethodCallRoot(_) => write!(f, "MethodCallRoot"),
            AnyNode::ArrayMethodName(_) => write!(f, "ArrayMethodName"),
            AnyNode::StringLiteral(_) => write!(f, "StringLiteral"),
            AnyNode::NetLvalue(_) => write!(f, "NetLvalue"),
            AnyNode::NetLvalueIdentifier(_) => write!(f, "NetLvalueIdentifier"),
            AnyNode::NetLvalueLvalue(_) => write!(f, "NetLvalueLvalue"),
            AnyNode::NetLvaluePattern(_) => write!(f, "NetLvaluePattern"),
            AnyNode::VariableLvalue(_) => write!(f, "VariableLvalue"),
            AnyNode::VariableLvalueIdentifier(_) => write!(f, "VariableLvalueIdentifier"),
            AnyNode::VariableLvalueLvalue(_) => write!(f, "VariableLvalueLvalue"),
            AnyNode::VariableLvaluePattern(_) => write!(f, "VariableLvaluePattern"),
            AnyNode::NonrangeVariableLvalue(_) => write!(f, "NonrangeVariableLvalue"),
            AnyNode::PreprocessorText(_) => write!(f, "PreprocessorText"),
            AnyNode::CmosSwitchtype(_) => write!(f, "CmosSwitchtype"),
            AnyNode::EnableGatetype(_) => write!(f, "EnableGatetype"),
            AnyNode::MosSwitchtype(_) => write!(f, "MosSwitchtype"),
            AnyNode::NInputGatetype(_) => write!(f, "NInputGatetype"),
            AnyNode::NOutputGatetype(_) => write!(f, "NOutputGatetype"),
            AnyNode::PassEnSwitchtype(_) => write!(f, "PassEnSwitchtype"),
            AnyNode::PassSwitchtype(_) => write!(f, "PassSwitchtype"),
            AnyNode::PulldownStrength(_) => write!(f, "PulldownStrength"),
            AnyNode::PulldownStrength01(_) => write!(f, "PulldownStrength01"),
            AnyNode::PulldownStrength10(_) => write!(f, "PulldownStrength10"),
            AnyNode::PulldownStrength0(_) => write!(f, "PulldownStrength0"),
            AnyNode::PullupStrength(_) => write!(f, "PullupStrength"),
            AnyNode::PullupStrength01(_) => write!(f, "PullupStrength01"),
            AnyNode::PullupStrength10(_) => write!(f, "PullupStrength10"),
            AnyNode::PullupStrength1(_) => write!(f, "PullupStrength1"),
            AnyNode::EnableTerminal(_) => write!(f, "EnableTerminal"),
            AnyNode::InoutTerminal(_) => write!(f, "InoutTerminal"),
            AnyNode::InputTerminal(_) => write!(f, "InputTerminal"),
            AnyNode::NcontrolTerminal(_) => write!(f, "NcontrolTerminal"),
            AnyNode::OutputTerminal(_) => write!(f, "OutputTerminal"),
            AnyNode::PcontrolTerminal(_) => write!(f, "PcontrolTerminal"),
            AnyNode::GateInstantiation(_) => write!(f, "GateInstantiation"),
            AnyNode::GateInstantiationCmos(_) => write!(f, "GateInstantiationCmos"),
            AnyNode::GateInstantiationEnable(_) => write!(f, "GateInstantiationEnable"),
            AnyNode::GateInstantiationMos(_) => write!(f, "GateInstantiationMos"),
            AnyNode::GateInstantiationNInput(_) => write!(f, "GateInstantiationNInput"),
            AnyNode::GateInstantiationNOutput(_) => write!(f, "GateInstantiationNOutput"),
            AnyNode::GateInstantiationPassEn(_) => write!(f, "GateInstantiationPassEn"),
            AnyNode::GateInstantiationPass(_) => write!(f, "GateInstantiationPass"),
            AnyNode::GateInstantiationPulldown(_) => write!(f, "GateInstantiationPulldown"),
            AnyNode::GateInstantiationPullup(_) => write!(f, "GateInstantiationPullup"),
            AnyNode::CmosSwitchInstance(_) => write!(f, "CmosSwitchInstance"),
            AnyNode::EnableGateInstance(_) => write!(f, "EnableGateInstance"),
            AnyNode::MosSwitchInstance(_) => write!(f, "MosSwitchInstance"),
            AnyNode::NInputGateInstance(_) => write!(f, "NInputGateInstance"),
            AnyNode::NOutputGateInstance(_) => write!(f, "NOutputGateInstance"),
            AnyNode::PassSwitchInstance(_) => write!(f, "PassSwitchInstance"),
            AnyNode::PassEnableSwitchInstance(_) => write!(f, "PassEnableSwitchInstance"),
            AnyNode::PullGateInstance(_) => write!(f, "PullGateInstance"),
            AnyNode::ConcurrentAssertionItem(_) => write!(f, "ConcurrentAssertionItem"),
            AnyNode::ConcurrentAssertionItemStatement(_) => write!(f, "ConcurrentAssertionItemStatement"),
            AnyNode::ConcurrentAssertionStatement(_) => write!(f, "ConcurrentAssertionStatement"),
            AnyNode::AssertPropertyStatement(_) => write!(f, "AssertPropertyStatement"),
            AnyNode::AssumePropertyStatement(_) => write!(f, "AssumePropertyStatement"),
            AnyNode::CoverPropertyStatement(_) => write!(f, "CoverPropertyStatement"),
            AnyNode::ExpectPropertyStatement(_) => write!(f, "ExpectPropertyStatement"),
            AnyNode::CoverSequenceStatement(_) => write!(f, "CoverSequenceStatement"),
            AnyNode::RestrictPropertyStatement(_) => write!(f, "RestrictPropertyStatement"),
            AnyNode::PropertyInstance(_) => write!(f, "PropertyInstance"),
            AnyNode::PropertyListOfArguments(_) => write!(f, "PropertyListOfArguments"),
            AnyNode::PropertyListOfArgumentsOrdered(_) => write!(f, "PropertyListOfArgumentsOrdered"),
            AnyNode::PropertyListOfArgumentsNamed(_) => write!(f, "PropertyListOfArgumentsNamed"),
            AnyNode::PropertyActualArg(_) => write!(f, "PropertyActualArg"),
            AnyNode::AssertionItemDeclaration(_) => write!(f, "AssertionItemDeclaration"),
            AnyNode::PropertyDeclaration(_) => write!(f, "PropertyDeclaration"),
            AnyNode::PropertyPortList(_) => write!(f, "PropertyPortList"),
            AnyNode::PropertyPortItem(_) => write!(f, "PropertyPortItem"),
            AnyNode::PropertyLvarPortDirection(_) => write!(f, "PropertyLvarPortDirection"),
            AnyNode::PropertyFormalType(_) => write!(f, "PropertyFormalType"),
            AnyNode::PropertySpec(_) => write!(f, "PropertySpec"),
            AnyNode::PropertyExpr(_) => write!(f, "PropertyExpr"),
            AnyNode::PropertyExprStrong(_) => write!(f, "PropertyExprStrong"),
            AnyNode::PropertyExprWeak(_) => write!(f, "PropertyExprWeak"),
            AnyNode::PropertyExprParen(_) => write!(f, "PropertyExprParen"),
            AnyNode::PropertyExprNot(_) => write!(f, "PropertyExprNot"),
            AnyNode::PropertyExprBinaryProperty(_) => write!(f, "PropertyExprBinaryProperty"),
            AnyNode::PropertyExprBinarySequence(_) => write!(f, "PropertyExprBinarySequence"),
            AnyNode::PropertyExprIf(_) => write!(f, "PropertyExprIf"),
            AnyNode::PropertyExprCase(_) => write!(f, "PropertyExprCase"),
            AnyNode::PropertyExprNexttime(_) => write!(f, "PropertyExprNexttime"),
            AnyNode::PropertyExprSNexttime(_) => write!(f, "PropertyExprSNexttime"),
            AnyNode::PropertyExprAlways(_) => write!(f, "PropertyExprAlways"),
            AnyNode::PropertyExprSAlways(_) => write!(f, "PropertyExprSAlways"),
            AnyNode::PropertyExprEventually(_) => write!(f, "PropertyExprEventually"),
            AnyNode::PropertyExprSEventually(_) => write!(f, "PropertyExprSEventually"),
            AnyNode::PropertyExprAcceptOn(_) => write!(f, "PropertyExprAcceptOn"),
            AnyNode::PropertyExprRejectOn(_) => write!(f, "PropertyExprRejectOn"),
            AnyNode::PropertyExprSyncAcceptOn(_) => write!(f, "PropertyExprSyncAcceptOn"),
            AnyNode::PropertyExprSyncRejectOn(_) => write!(f, "PropertyExprSyncRejectOn"),
            AnyNode::PropertyExprClockingEvent(_) => write!(f, "PropertyExprClockingEvent"),
            AnyNode::PropertyCaseItem(_) => write!(f, "PropertyCaseItem"),
            AnyNode::PropertyCaseItemNondefault(_) => write!(f, "PropertyCaseItemNondefault"),
            AnyNode::PropertyCaseItemDefault(_) => write!(f, "PropertyCaseItemDefault"),
            AnyNode::SequenceDeclaration(_) => write!(f, "SequenceDeclaration"),
            AnyNode::SequencePortList(_) => write!(f, "SequencePortList"),
            AnyNode::SequencePortItem(_) => write!(f, "SequencePortItem"),
            AnyNode::SequenceLvarPortDirection(_) => write!(f, "SequenceLvarPortDirection"),
            AnyNode::SequenceFormalType(_) => write!(f, "SequenceFormalType"),
            AnyNode::SequenceExpr(_) => write!(f, "SequenceExpr"),
            AnyNode::SequenceExprCycleDelayExpr(_) => write!(f, "SequenceExprCycleDelayExpr"),
            AnyNode::SequenceExprExprCycleDelayExpr(_) => write!(f, "SequenceExprExprCycleDelayExpr"),
            AnyNode::SequenceExprExpression(_) => write!(f, "SequenceExprExpression"),
            AnyNode::SequenceExprInstance(_) => write!(f, "SequenceExprInstance"),
            AnyNode::SequenceExprParen(_) => write!(f, "SequenceExprParen"),
            AnyNode::SequenceExprBinary(_) => write!(f, "SequenceExprBinary"),
            AnyNode::SequenceExprFirstMatch(_) => write!(f, "SequenceExprFirstMatch"),
            AnyNode::SequenceExprThroughout(_) => write!(f, "SequenceExprThroughout"),
            AnyNode::SequenceExprClockingEvent(_) => write!(f, "SequenceExprClockingEvent"),
            AnyNode::CycleDelayRange(_) => write!(f, "CycleDelayRange"),
            AnyNode::CycleDelayRangePrimary(_) => write!(f, "CycleDelayRangePrimary"),
            AnyNode::CycleDelayRangeExpression(_) => write!(f, "CycleDelayRangeExpression"),
            AnyNode::CycleDelayRangeAsterisk(_) => write!(f, "CycleDelayRangeAsterisk"),
            AnyNode::CycleDelayRangePlus(_) => write!(f, "CycleDelayRangePlus"),
            AnyNode::SequenceMethodCall(_) => write!(f, "SequenceMethodCall"),
            AnyNode::SequenceMatchItem(_) => write!(f, "SequenceMatchItem"),
            AnyNode::SequenceInstance(_) => write!(f, "SequenceInstance"),
            AnyNode::SequenceListOfArguments(_) => write!(f, "SequenceListOfArguments"),
            AnyNode::SequenceListOfArgumentsOrdered(_) => write!(f, "SequenceListOfArgumentsOrdered"),
            AnyNode::SequenceListOfArgumentsNamed(_) => write!(f, "SequenceListOfArgumentsNamed"),
            AnyNode::SequenceActualArg(_) => write!(f, "SequenceActualArg"),
            AnyNode::BooleanAbbrev(_) => write!(f, "BooleanAbbrev"),
            AnyNode::SequenceAbbrev(_) => write!(f, "SequenceAbbrev"),
            AnyNode::ConsecutiveRepetition(_) => write!(f, "ConsecutiveRepetition"),
            AnyNode::ConsecutiveRepetitionExpression(_) => write!(f, "ConsecutiveRepetitionExpression"),
            AnyNode::ConsecutiveRepetitionAsterisk(_) => write!(f, "ConsecutiveRepetitionAsterisk"),
            AnyNode::ConsecutiveRepetitionPlus(_) => write!(f, "ConsecutiveRepetitionPlus"),
            AnyNode::NonConsecutiveRepetition(_) => write!(f, "NonConsecutiveRepetition"),
            AnyNode::GotoRepetition(_) => write!(f, "GotoRepetition"),
            AnyNode::ConstOrRangeExpression(_) => write!(f, "ConstOrRangeExpression"),
            AnyNode::CycleDelayConstRangeExpression(_) => write!(f, "CycleDelayConstRangeExpression"),
            AnyNode::CycleDelayConstRangeExpressionBinary(_) => write!(f, "CycleDelayConstRangeExpressionBinary"),
            AnyNode::CycleDelayConstRangeExpressionDollar(_) => write!(f, "CycleDelayConstRangeExpressionDollar"),
            AnyNode::ExpressionOrDist(_) => write!(f, "ExpressionOrDist"),
            AnyNode::AssertionVariableDeclaration(_) => write!(f, "AssertionVariableDeclaration"),
            AnyNode::TaskDeclaration(_) => write!(f, "TaskDeclaration"),
            AnyNode::TaskBodyDeclaration(_) => write!(f, "TaskBodyDeclaration"),
            AnyNode::TaskBodyDeclarationWithoutPort(_) => write!(f, "TaskBodyDeclarationWithoutPort"),
            AnyNode::TaskBodyDeclarationWithPort(_) => write!(f, "TaskBodyDeclarationWithPort"),
            AnyNode::TfItemDeclaration(_) => write!(f, "TfItemDeclaration"),
            AnyNode::TfPortList(_) => write!(f, "TfPortList"),
            AnyNode::TfPortItem(_) => write!(f, "TfPortItem"),
            AnyNode::TfPortDirection(_) => write!(f, "TfPortDirection"),
            AnyNode::TfPortDeclaration(_) => write!(f, "TfPortDeclaration"),
            AnyNode::TaskPrototype(_) => write!(f, "TaskPrototype"),
            AnyNode::DefparamAssignment(_) => write!(f, "DefparamAssignment"),
            AnyNode::NetDeclAssignment(_) => write!(f, "NetDeclAssignment"),
            AnyNode::ParamAssignment(_) => write!(f, "ParamAssignment"),
            AnyNode::SpecparamAssignment(_) => write!(f, "SpecparamAssignment"),
            AnyNode::SpecparamAssignmentMintypmax(_) => write!(f, "SpecparamAssignmentMintypmax"),
            AnyNode::TypeAssignment(_) => write!(f, "TypeAssignment"),
            AnyNode::PulseControlSpecparam(_) => write!(f, "PulseControlSpecparam"),
            AnyNode::PulseControlSpecparamWithoutDescriptor(_) => write!(f, "PulseControlSpecparamWithoutDescriptor"),
            AnyNode::PulseControlSpecparamWithDescriptor(_) => write!(f, "PulseControlSpecparamWithDescriptor"),
            AnyNode::ErrorLimitValue(_) => write!(f, "ErrorLimitValue"),
            AnyNode::RejectLimitValue(_) => write!(f, "RejectLimitValue"),
            AnyNode::LimitValue(_) => write!(f, "LimitValue"),
            AnyNode::VariableDeclAssignment(_) => write!(f, "VariableDeclAssignment"),
            AnyNode::VariableDeclAssignmentVariable(_) => write!(f, "VariableDeclAssignmentVariable"),
            AnyNode::VariableDeclAssignmentDynamicArray(_) => write!(f, "VariableDeclAssignmentDynamicArray"),
            AnyNode::VariableDeclAssignmentClass(_) => write!(f, "VariableDeclAssignmentClass"),
            AnyNode::ClassNew(_) => write!(f, "ClassNew"),
            AnyNode::ClassNewArgument(_) => write!(f, "ClassNewArgument"),
            AnyNode::ClassNewExpression(_) => write!(f, "ClassNewExpression"),
            AnyNode::DynamicArrayNew(_) => write!(f, "DynamicArrayNew"),
            AnyNode::ListOfDefparamAssignments(_) => write!(f, "ListOfDefparamAssignments"),
            AnyNode::ListOfGenvarIdentifiers(_) => write!(f, "ListOfGenvarIdentifiers"),
            AnyNode::ListOfInterfaceIdentifiers(_) => write!(f, "ListOfInterfaceIdentifiers"),
            AnyNode::ListOfNetDeclAssignments(_) => write!(f, "ListOfNetDeclAssignments"),
            AnyNode::ListOfParamAssignments(_) => write!(f, "ListOfParamAssignments"),
            AnyNode::ListOfPortIdentifiers(_) => write!(f, "ListOfPortIdentifiers"),
            AnyNode::ListOfUdpPortIdentifiers(_) => write!(f, "ListOfUdpPortIdentifiers"),
            AnyNode::ListOfSpecparamAssignments(_) => write!(f, "ListOfSpecparamAssignments"),
            AnyNode::ListOfTfVariableIdentifiers(_) => write!(f, "ListOfTfVariableIdentifiers"),
            AnyNode::ListOfTypeAssignments(_) => write!(f, "ListOfTypeAssignments"),
            AnyNode::ListOfVariableDeclAssignments(_) => write!(f, "ListOfVariableDeclAssignments"),
            AnyNode::ListOfVariableIdentifiers(_) => write!(f, "ListOfVariableIdentifiers"),
            AnyNode::ListOfVariablePortIdentifiers(_) => write!(f, "ListOfVariablePortIdentifiers"),
            AnyNode::DataDeclaration(_) => write!(f, "DataDeclaration"),
            AnyNode::DataDeclarationVariable(_) => write!(f, "DataDeclarationVariable"),
            AnyNode::Const(_) => write!(f, "Const"),
            AnyNode::PackageImportDeclaration(_) => write!(f, "PackageImportDeclaration"),
            AnyNode::PackageImportItem(_) => write!(f, "PackageImportItem"),
            AnyNode::PackageImportItemIdentifier(_) => write!(f, "PackageImportItemIdentifier"),
            AnyNode::PackageImportItemAsterisk(_) => write!(f, "PackageImportItemAsterisk"),
            AnyNode::PackageExportDeclaration(_) => write!(f, "PackageExportDeclaration"),
            AnyNode::PackageExportDeclarationAsterisk(_) => write!(f, "PackageExportDeclarationAsterisk"),
            AnyNode::PackageExportDeclarationItem(_) => write!(f, "PackageExportDeclarationItem"),
            AnyNode::GenvarDeclaration(_) => write!(f, "GenvarDeclaration"),
            AnyNode::NetDeclaration(_) => write!(f, "NetDeclaration"),
            AnyNode::NetDeclarationNetType(_) => write!(f, "NetDeclarationNetType"),
            AnyNode::Strength(_) => write!(f, "Strength"),
            AnyNode::VectorScalar(_) => write!(f, "VectorScalar"),
            AnyNode::NetDeclarationNetTypeIdentifier(_) => write!(f, "NetDeclarationNetTypeIdentifier"),
            AnyNode::NetDeclarationInterconnect(_) => write!(f, "NetDeclarationInterconnect"),
            AnyNode::TypeDeclaration(_) => write!(f, "TypeDeclaration"),
            AnyNode::TypeDeclarationDataType(_) => write!(f, "TypeDeclarationDataType"),
            AnyNode::TypeDeclarationInterface(_) => write!(f, "TypeDeclarationInterface"),
            AnyNode::TypeDeclarationReserved(_) => write!(f, "TypeDeclarationReserved"),
            AnyNode::TypeDeclarationKeyword(_) => write!(f, "TypeDeclarationKeyword"),
            AnyNode::NetTypeDeclaration(_) => write!(f, "NetTypeDeclaration"),
            AnyNode::NetTypeDeclarationDataType(_) => write!(f, "NetTypeDeclarationDataType"),
            AnyNode::NetTypeDeclarationNetType(_) => write!(f, "NetTypeDeclarationNetType"),
            AnyNode::Lifetime(_) => write!(f, "Lifetime"),
            AnyNode::DriveStrength(_) => write!(f, "DriveStrength"),
            AnyNode::DriveStrength01(_) => write!(f, "DriveStrength01"),
            AnyNode::DriveStrength10(_) => write!(f, "DriveStrength10"),
            AnyNode::DriveStrength0z(_) => write!(f, "DriveStrength0z"),
            AnyNode::DriveStrength1z(_) => write!(f, "DriveStrength1z"),
            AnyNode::DriveStrengthz1(_) => write!(f, "DriveStrengthz1"),
            AnyNode::DriveStrengthz0(_) => write!(f, "DriveStrengthz0"),
            AnyNode::Strength0(_) => write!(f, "Strength0"),
            AnyNode::Strength1(_) => write!(f, "Strength1"),
            AnyNode::ChargeStrength(_) => write!(f, "ChargeStrength"),
            AnyNode::ChargeStrengthSmall(_) => write!(f, "ChargeStrengthSmall"),
            AnyNode::ChargeStrengthMedium(_) => write!(f, "ChargeStrengthMedium"),
            AnyNode::ChargeStrengthLarge(_) => write!(f, "ChargeStrengthLarge"),
            AnyNode::LetDeclaration(_) => write!(f, "LetDeclaration"),
            AnyNode::LetIdentifier(_) => write!(f, "LetIdentifier"),
            AnyNode::LetPortList(_) => write!(f, "LetPortList"),
            AnyNode::LetPortItem(_) => write!(f, "LetPortItem"),
            AnyNode::LetFormalType(_) => write!(f, "LetFormalType"),
            AnyNode::LetExpression(_) => write!(f, "LetExpression"),
            AnyNode::LetListOfArguments(_) => write!(f, "LetListOfArguments"),
            AnyNode::LetListOfArgumentsOrdered(_) => write!(f, "LetListOfArgumentsOrdered"),
            AnyNode::LetListOfArgumentsNamed(_) => write!(f, "LetListOfArgumentsNamed"),
            AnyNode::LetActualArg(_) => write!(f, "LetActualArg"),
            AnyNode::InoutDeclaration(_) => write!(f, "InoutDeclaration"),
            AnyNode::InputDeclaration(_) => write!(f, "InputDeclaration"),
            AnyNode::InputDeclarationNet(_) => write!(f, "InputDeclarationNet"),
            AnyNode::InputDeclarationVariable(_) => write!(f, "InputDeclarationVariable"),
            AnyNode::OutputDeclaration(_) => write!(f, "OutputDeclaration"),
            AnyNode::OutputDeclarationNet(_) => write!(f, "OutputDeclarationNet"),
            AnyNode::OutputDeclarationVariable(_) => write!(f, "OutputDeclarationVariable"),
            AnyNode::InterfacePortDeclaration(_) => write!(f, "InterfacePortDeclaration"),
            AnyNode::RefDeclaration(_) => write!(f, "RefDeclaration"),
            AnyNode::UnpackedDimension(_) => write!(f, "UnpackedDimension"),
            AnyNode::UnpackedDimensionRange(_) => write!(f, "UnpackedDimensionRange"),
            AnyNode::UnpackedDimensionExpression(_) => write!(f, "UnpackedDimensionExpression"),
            AnyNode::PackedDimension(_) => write!(f, "PackedDimension"),
            AnyNode::PackedDimensionRange(_) => write!(f, "PackedDimensionRange"),
            AnyNode::AssociativeDimension(_) => write!(f, "AssociativeDimension"),
            AnyNode::AssociativeDimensionDataType(_) => write!(f, "AssociativeDimensionDataType"),
            AnyNode::AssociativeDimensionAsterisk(_) => write!(f, "AssociativeDimensionAsterisk"),
            AnyNode::VariableDimension(_) => write!(f, "VariableDimension"),
            AnyNode::QueueDimension(_) => write!(f, "QueueDimension"),
            AnyNode::UnsizedDimension(_) => write!(f, "UnsizedDimension"),
            AnyNode::LocalParameterDeclaration(_) => write!(f, "LocalParameterDeclaration"),
            AnyNode::LocalParameterDeclarationParam(_) => write!(f, "LocalParameterDeclarationParam"),
            AnyNode::LocalParameterDeclarationType(_) => write!(f, "LocalParameterDeclarationType"),
            AnyNode::ParameterDeclaration(_) => write!(f, "ParameterDeclaration"),
            AnyNode::ParameterDeclarationParam(_) => write!(f, "ParameterDeclarationParam"),
            AnyNode::ParameterDeclarationType(_) => write!(f, "ParameterDeclarationType"),
            AnyNode::SpecparamDeclaration(_) => write!(f, "SpecparamDeclaration"),
            AnyNode::CovergroupDeclaration(_) => write!(f, "CovergroupDeclaration"),
            AnyNode::CoverageSpecOrOption(_) => write!(f, "CoverageSpecOrOption"),
            AnyNode::CoverageSpecOrOptionSpec(_) => write!(f, "CoverageSpecOrOptionSpec"),
            AnyNode::CoverageSpecOrOptionOption(_) => write!(f, "CoverageSpecOrOptionOption"),
            AnyNode::CoverageOption(_) => write!(f, "CoverageOption"),
            AnyNode::CoverageOptionOption(_) => write!(f, "CoverageOptionOption"),
            AnyNode::CoverageOptionTypeOption(_) => write!(f, "CoverageOptionTypeOption"),
            AnyNode::CoverageSpec(_) => write!(f, "CoverageSpec"),
            AnyNode::CoverageEvent(_) => write!(f, "CoverageEvent"),
            AnyNode::CoverageEventSample(_) => write!(f, "CoverageEventSample"),
            AnyNode::CoverageEventAt(_) => write!(f, "CoverageEventAt"),
            AnyNode::BlockEventExpression(_) => write!(f, "BlockEventExpression"),
            AnyNode::BlockEventExpressionOr(_) => write!(f, "BlockEventExpressionOr"),
            AnyNode::BlockEventExpressionBegin(_) => write!(f, "BlockEventExpressionBegin"),
            AnyNode::BlockEventExpressionEnd(_) => write!(f, "BlockEventExpressionEnd"),
            AnyNode::HierarchicalBtfIdentifier(_) => write!(f, "HierarchicalBtfIdentifier"),
            AnyNode::HierarchicalBtfIdentifierMethod(_) => write!(f, "HierarchicalBtfIdentifierMethod"),
            AnyNode::HierarchicalIdentifierOrClassScope(_) => write!(f, "HierarchicalIdentifierOrClassScope"),
            AnyNode::CoverPoint(_) => write!(f, "CoverPoint"),
            AnyNode::BinsOrEmpty(_) => write!(f, "BinsOrEmpty"),
            AnyNode::BinsOrEmptyNonEmpty(_) => write!(f, "BinsOrEmptyNonEmpty"),
            AnyNode::BinsOrOptions(_) => write!(f, "BinsOrOptions"),
            AnyNode::BinsOrOptionsCovergroup(_) => write!(f, "BinsOrOptionsCovergroup"),
            AnyNode::Wildcard(_) => write!(f, "Wildcard"),
            AnyNode::BinsOrOptionsCoverPoint(_) => write!(f, "BinsOrOptionsCoverPoint"),
            AnyNode::BinsOrOptionsSetCovergroup(_) => write!(f, "BinsOrOptionsSetCovergroup"),
            AnyNode::BinsOrOptionsTransList(_) => write!(f, "BinsOrOptionsTransList"),
            AnyNode::BinsOrOptionsDefault(_) => write!(f, "BinsOrOptionsDefault"),
            AnyNode::BinsOrOptionsDefaultSequence(_) => write!(f, "BinsOrOptionsDefaultSequence"),
            AnyNode::BinsKeyword(_) => write!(f, "BinsKeyword"),
            AnyNode::TransList(_) => write!(f, "TransList"),
            AnyNode::TransSet(_) => write!(f, "TransSet"),
            AnyNode::TransRangeList(_) => write!(f, "TransRangeList"),
            AnyNode::TransRangeListAsterisk(_) => write!(f, "TransRangeListAsterisk"),
            AnyNode::TransRangeListArrow(_) => write!(f, "TransRangeListArrow"),
            AnyNode::TransRangeListEqual(_) => write!(f, "TransRangeListEqual"),
            AnyNode::TransItem(_) => write!(f, "TransItem"),
            AnyNode::RepeatRange(_) => write!(f, "RepeatRange"),
            AnyNode::RepeatRangeBinary(_) => write!(f, "RepeatRangeBinary"),
            AnyNode::CoverCross(_) => write!(f, "CoverCross"),
            AnyNode::ListOfCrossItems(_) => write!(f, "ListOfCrossItems"),
            AnyNode::CrossItem(_) => write!(f, "CrossItem"),
            AnyNode::CrossBody(_) => write!(f, "CrossBody"),
            AnyNode::CrossBodyNonEmpty(_) => write!(f, "CrossBodyNonEmpty"),
            AnyNode::CrossBodyItem(_) => write!(f, "CrossBodyItem"),
            AnyNode::BinsSelectionOrOption(_) => write!(f, "BinsSelectionOrOption"),
            AnyNode::BinsSelectionOrOptionCoverage(_) => write!(f, "BinsSelectionOrOptionCoverage"),
            AnyNode::BinsSelectionOrOptionBins(_) => write!(f, "BinsSelectionOrOptionBins"),
            AnyNode::BinsSelection(_) => write!(f, "BinsSelection"),
            AnyNode::SelectExpression(_) => write!(f, "SelectExpression"),
            AnyNode::SelectExpressionNot(_) => write!(f, "SelectExpressionNot"),
            AnyNode::SelectExpressionAnd(_) => write!(f, "SelectExpressionAnd"),
            AnyNode::SelectExpressionOr(_) => write!(f, "SelectExpressionOr"),
            AnyNode::SelectExpressionParen(_) => write!(f, "SelectExpressionParen"),
            AnyNode::SelectExpressionWith(_) => write!(f, "SelectExpressionWith"),
            AnyNode::SelectExpressionCrossSet(_) => write!(f, "SelectExpressionCrossSet"),
            AnyNode::SelectCondition(_) => write!(f, "SelectCondition"),
            AnyNode::BinsExpression(_) => write!(f, "BinsExpression"),
            AnyNode::BinsExpressionCoverPoint(_) => write!(f, "BinsExpressionCoverPoint"),
            AnyNode::CovergroupRangeList(_) => write!(f, "CovergroupRangeList"),
            AnyNode::CovergroupValueRange(_) => write!(f, "CovergroupValueRange"),
            AnyNode::CovergroupValueRangeBinary(_) => write!(f, "CovergroupValueRangeBinary"),
            AnyNode::WithCovergroupExpression(_) => write!(f, "WithCovergroupExpression"),
            AnyNode::SetCovergroupExpression(_) => write!(f, "SetCovergroupExpression"),
            AnyNode::IntegerCovergroupExpression(_) => write!(f, "IntegerCovergroupExpression"),
            AnyNode::CrossSetExpression(_) => write!(f, "CrossSetExpression"),
            AnyNode::CovergroupExpression(_) => write!(f, "CovergroupExpression"),
            AnyNode::BlockItemDeclaration(_) => write!(f, "BlockItemDeclaration"),
            AnyNode::BlockItemDeclarationData(_) => write!(f, "BlockItemDeclarationData"),
            AnyNode::BlockItemDeclarationLocalParameter(_) => write!(f, "BlockItemDeclarationLocalParameter"),
            AnyNode::BlockItemDeclarationParameter(_) => write!(f, "BlockItemDeclarationParameter"),
            AnyNode::BlockItemDeclarationLet(_) => write!(f, "BlockItemDeclarationLet"),
            AnyNode::Delay3(_) => write!(f, "Delay3"),
            AnyNode::Delay3Single(_) => write!(f, "Delay3Single"),
            AnyNode::Delay3Mintypmax(_) => write!(f, "Delay3Mintypmax"),
            AnyNode::Delay2(_) => write!(f, "Delay2"),
            AnyNode::Delay2Single(_) => write!(f, "Delay2Single"),
            AnyNode::Delay2Mintypmax(_) => write!(f, "Delay2Mintypmax"),
            AnyNode::DelayValue(_) => write!(f, "DelayValue"),
            AnyNode::ModportDeclaration(_) => write!(f, "ModportDeclaration"),
            AnyNode::ModportItem(_) => write!(f, "ModportItem"),
            AnyNode::ModportPortsDeclaration(_) => write!(f, "ModportPortsDeclaration"),
            AnyNode::ModportPortsDeclarationSimple(_) => write!(f, "ModportPortsDeclarationSimple"),
            AnyNode::ModportPortsDeclarationTf(_) => write!(f, "ModportPortsDeclarationTf"),
            AnyNode::ModportPortsDeclarationClocking(_) => write!(f, "ModportPortsDeclarationClocking"),
            AnyNode::ModportClockingDeclaration(_) => write!(f, "ModportClockingDeclaration"),
            AnyNode::ModportSimplePortsDeclaration(_) => write!(f, "ModportSimplePortsDeclaration"),
            AnyNode::ModportSimplePort(_) => write!(f, "ModportSimplePort"),
            AnyNode::ModportSimplePortOrdered(_) => write!(f, "ModportSimplePortOrdered"),
            AnyNode::ModportSimplePortNamed(_) => write!(f, "ModportSimplePortNamed"),
            AnyNode::ModportTfPortsDeclaration(_) => write!(f, "ModportTfPortsDeclaration"),
            AnyNode::ModportTfPort(_) => write!(f, "ModportTfPort"),
            AnyNode::ImportExport(_) => write!(f, "ImportExport"),
            AnyNode::CastingType(_) => write!(f, "CastingType"),
            AnyNode::DataType(_) => write!(f, "DataType"),
            AnyNode::DataTypeVector(_) => write!(f, "DataTypeVector"),
            AnyNode::DataTypeAtom(_) => write!(f, "DataTypeAtom"),
            AnyNode::DataTypeStructUnion(_) => write!(f, "DataTypeStructUnion"),
            AnyNode::Packed(_) => write!(f, "Packed"),
            AnyNode::DataTypeEnum(_) => write!(f, "DataTypeEnum"),
            AnyNode::DataTypeVirtual(_) => write!(f, "DataTypeVirtual"),
            AnyNode::Interface(_) => write!(f, "Interface"),
            AnyNode::DataTypeType(_) => write!(f, "DataTypeType"),
            AnyNode::DataTypeOrImplicit(_) => write!(f, "DataTypeOrImplicit"),
            AnyNode::ImplicitDataType(_) => write!(f, "ImplicitDataType"),
            AnyNode::EnumBaseType(_) => write!(f, "EnumBaseType"),
            AnyNode::EnumBaseTypeAtom(_) => write!(f, "EnumBaseTypeAtom"),
            AnyNode::EnumBaseTypeVector(_) => write!(f, "EnumBaseTypeVector"),
            AnyNode::EnumBaseTypeType(_) => write!(f, "EnumBaseTypeType"),
            AnyNode::EnumNameDeclaration(_) => write!(f, "EnumNameDeclaration"),
            AnyNode::ClassScope(_) => write!(f, "ClassScope"),
            AnyNode::ClassType(_) => write!(f, "ClassType"),
            AnyNode::IntegerType(_) => write!(f, "IntegerType"),
            AnyNode::IntegerAtomType(_) => write!(f, "IntegerAtomType"),
            AnyNode::IntegerVectorType(_) => write!(f, "IntegerVectorType"),
            AnyNode::NonIntegerType(_) => write!(f, "NonIntegerType"),
            AnyNode::NetType(_) => write!(f, "NetType"),
            AnyNode::NetPortType(_) => write!(f, "NetPortType"),
            AnyNode::NetPortTypeDataType(_) => write!(f, "NetPortTypeDataType"),
            AnyNode::NetPortTypeInterconnect(_) => write!(f, "NetPortTypeInterconnect"),
            AnyNode::VariablePortType(_) => write!(f, "VariablePortType"),
            AnyNode::VarDataType(_) => write!(f, "VarDataType"),
            AnyNode::VarDataTypeVar(_) => write!(f, "VarDataTypeVar"),
            AnyNode::Signing(_) => write!(f, "Signing"),
            AnyNode::SimpleType(_) => write!(f, "SimpleType"),
            AnyNode::StructUnionMember(_) => write!(f, "StructUnionMember"),
            AnyNode::DataTypeOrVoid(_) => write!(f, "DataTypeOrVoid"),
            AnyNode::StructUnion(_) => write!(f, "StructUnion"),
            AnyNode::TypeReference(_) => write!(f, "TypeReference"),
            AnyNode::TypeReferenceExpression(_) => write!(f, "TypeReferenceExpression"),
            AnyNode::TypeReferenceDataType(_) => write!(f, "TypeReferenceDataType"),
            AnyNode::FunctionDataTypeOrImplicit(_) => write!(f, "FunctionDataTypeOrImplicit"),
            AnyNode::FunctionDeclaration(_) => write!(f, "FunctionDeclaration"),
            AnyNode::FunctionBodyDeclaration(_) => write!(f, "FunctionBodyDeclaration"),
            AnyNode::FunctionBodyDeclarationWithoutPort(_) => write!(f, "FunctionBodyDeclarationWithoutPort"),
            AnyNode::FunctionBodyDeclarationWithPort(_) => write!(f, "FunctionBodyDeclarationWithPort"),
            AnyNode::InterfaceIdentifierOrClassScope(_) => write!(f, "InterfaceIdentifierOrClassScope"),
            AnyNode::FunctionPrototype(_) => write!(f, "FunctionPrototype"),
            AnyNode::DpiImportExport(_) => write!(f, "DpiImportExport"),
            AnyNode::DpiImportExportImportFunction(_) => write!(f, "DpiImportExportImportFunction"),
            AnyNode::DpiImportExportImportTask(_) => write!(f, "DpiImportExportImportTask"),
            AnyNode::DpiImportExportExportFunction(_) => write!(f, "DpiImportExportExportFunction"),
            AnyNode::DpiImportExportExportTask(_) => write!(f, "DpiImportExportExportTask"),
            AnyNode::DpiSpecString(_) => write!(f, "DpiSpecString"),
            AnyNode::DpiFunctionImportProperty(_) => write!(f, "DpiFunctionImportProperty"),
            AnyNode::DpiTaskImportProperty(_) => write!(f, "DpiTaskImportProperty"),
            AnyNode::DpiFunctionProto(_) => write!(f, "DpiFunctionProto"),
            AnyNode::DpiTaskProto(_) => write!(f, "DpiTaskProto"),
            AnyNode::Symbol(_) => write!(f, "Symbol"),
            AnyNode::Keyword(_) => write!(f, "Keyword"),
            AnyNode::WhiteSpace(_) => write!(f, "WhiteSpace"),
            AnyNode::TimingCheckEvent(_) => write!(f, "TimingCheckEvent"),
            AnyNode::ControlledTimingCheckEvent(_) => write!(f, "ControlledTimingCheckEvent"),
            AnyNode::TimingCheckEventControl(_) => write!(f, "TimingCheckEventControl"),
            AnyNode::SpecifyTerminalDescriptor(_) => write!(f, "SpecifyTerminalDescriptor"),
            AnyNode::EdgeControlSpecifier(_) => write!(f, "EdgeControlSpecifier"),
            AnyNode::EdgeDescriptor(_) => write!(f, "EdgeDescriptor"),
            AnyNode::TimingCheckCondition(_) => write!(f, "TimingCheckCondition"),
            AnyNode::TimingCheckConditionParen(_) => write!(f, "TimingCheckConditionParen"),
            AnyNode::ScalarTimingCheckCondition(_) => write!(f, "ScalarTimingCheckCondition"),
            AnyNode::ScalarTimingCheckConditionUnary(_) => write!(f, "ScalarTimingCheckConditionUnary"),
            AnyNode::ScalarTimingCheckConditionBinary(_) => write!(f, "ScalarTimingCheckConditionBinary"),
            AnyNode::ScalarConstant(_) => write!(f, "ScalarConstant"),
            AnyNode::SpecifyBlock(_) => write!(f, "SpecifyBlock"),
            AnyNode::SpecifyItem(_) => write!(f, "SpecifyItem"),
            AnyNode::PulsestyleDeclaration(_) => write!(f, "PulsestyleDeclaration"),
            AnyNode::ShowcancelledDeclaration(_) => write!(f, "ShowcancelledDeclaration"),
            AnyNode::SystemTimingCheck(_) => write!(f, "SystemTimingCheck"),
            AnyNode::SetupTimingCheck(_) => write!(f, "SetupTimingCheck"),
            AnyNode::HoldTimingCheck(_) => write!(f, "HoldTimingCheck"),
            AnyNode::SetupholdTimingCheck(_) => write!(f, "SetupholdTimingCheck"),
            AnyNode::RecoveryTimingCheck(_) => write!(f, "RecoveryTimingCheck"),
            AnyNode::RemovalTimingCheck(_) => write!(f, "RemovalTimingCheck"),
            AnyNode::RecremTimingCheck(_) => write!(f, "RecremTimingCheck"),
            AnyNode::SkewTimingCheck(_) => write!(f, "SkewTimingCheck"),
            AnyNode::TimeskewTimingCheck(_) => write!(f, "TimeskewTimingCheck"),
            AnyNode::FullskewTimingCheck(_) => write!(f, "FullskewTimingCheck"),
            AnyNode::PeriodTimingCheck(_) => write!(f, "PeriodTimingCheck"),
            AnyNode::WidthTimingCheck(_) => write!(f, "WidthTimingCheck"),
            AnyNode::NochangeTimingCheck(_) => write!(f, "NochangeTimingCheck"),
            AnyNode::PathDelayValue(_) => write!(f, "PathDelayValue"),
            AnyNode::PathDelayValueParen(_) => write!(f, "PathDelayValueParen"),
            AnyNode::ListOfPathDelayExpressions(_) => write!(f, "ListOfPathDelayExpressions"),
            AnyNode::TPathDelayExpression(_) => write!(f, "TPathDelayExpression"),
            AnyNode::PathDelayExpression(_) => write!(f, "PathDelayExpression"),
            AnyNode::EdgeSensitivePathDeclaration(_) => write!(f, "EdgeSensitivePathDeclaration"),
            AnyNode::EdgeSensitivePathDeclarationParallel(_) => write!(f, "EdgeSensitivePathDeclarationParallel"),
            AnyNode::EdgeSensitivePathDeclarationFull(_) => write!(f, "EdgeSensitivePathDeclarationFull"),
            AnyNode::ParallelEdgeSensitivePathDescription(_) => write!(f, "ParallelEdgeSensitivePathDescription"),
            AnyNode::FullEdgeSensitivePathDescription(_) => write!(f, "FullEdgeSensitivePathDescription"),
            AnyNode::DataSourceExpression(_) => write!(f, "DataSourceExpression"),
            AnyNode::EdgeIdentifier(_) => write!(f, "EdgeIdentifier"),
            AnyNode::StateDependentPathDeclaration(_) => write!(f, "StateDependentPathDeclaration"),
            AnyNode::StateDependentPathDeclarationIfSimple(_) => write!(f, "StateDependentPathDeclarationIfSimple"),
            AnyNode::StateDependentPathDeclarationIfEdgeSensitive(_) => write!(f, "StateDependentPathDeclarationIfEdgeSensitive"),
            AnyNode::StateDependentPathDeclarationIfNone(_) => write!(f, "StateDependentPathDeclarationIfNone"),
            AnyNode::PolarityOperator(_) => write!(f, "PolarityOperator"),
            AnyNode::TimecheckCondition(_) => write!(f, "TimecheckCondition"),
            AnyNode::ControlledReferenceEvent(_) => write!(f, "ControlledReferenceEvent"),
            AnyNode::DataEvent(_) => write!(f, "DataEvent"),
            AnyNode::DelayedData(_) => write!(f, "DelayedData"),
            AnyNode::DelayedDataWithMintypmax(_) => write!(f, "DelayedDataWithMintypmax"),
            AnyNode::DelayedReference(_) => write!(f, "DelayedReference"),
            AnyNode::DelayedReferenceWithMintypmax(_) => write!(f, "DelayedReferenceWithMintypmax"),
            AnyNode::EndEdgeOffset(_) => write!(f, "EndEdgeOffset"),
            AnyNode::EventBasedFlag(_) => write!(f, "EventBasedFlag"),
            AnyNode::Notifier(_) => write!(f, "Notifier"),
            AnyNode::ReferenceEvent(_) => write!(f, "ReferenceEvent"),
            AnyNode::RemainActiveFlag(_) => write!(f, "RemainActiveFlag"),
            AnyNode::TimestampCondition(_) => write!(f, "TimestampCondition"),
            AnyNode::StartEdgeOffset(_) => write!(f, "StartEdgeOffset"),
            AnyNode::Threshold(_) => write!(f, "Threshold"),
            AnyNode::TimingCheckLimit(_) => write!(f, "TimingCheckLimit"),
            AnyNode::PathDeclaration(_) => write!(f, "PathDeclaration"),
            AnyNode::SimplePathDeclaration(_) => write!(f, "SimplePathDeclaration"),
            AnyNode::SimplePathDeclarationParallel(_) => write!(f, "SimplePathDeclarationParallel"),
            AnyNode::SimplePathDeclarationFull(_) => write!(f, "SimplePathDeclarationFull"),
            AnyNode::ParallelPathDescription(_) => write!(f, "ParallelPathDescription"),
            AnyNode::FullPathDescription(_) => write!(f, "FullPathDescription"),
            AnyNode::ListOfPathInputs(_) => write!(f, "ListOfPathInputs"),
            AnyNode::ListOfPathOutputs(_) => write!(f, "ListOfPathOutputs"),
            AnyNode::SpecifyInputTerminalDescriptor(_) => write!(f, "SpecifyInputTerminalDescriptor"),
            AnyNode::SpecifyOutputTerminalDescriptor(_) => write!(f, "SpecifyOutputTerminalDescriptor"),
            AnyNode::InputIdentifier(_) => write!(f, "InputIdentifier"),
            AnyNode::InputIdentifierInterface(_) => write!(f, "InputIdentifierInterface"),
            AnyNode::OutputIdentifier(_) => write!(f, "OutputIdentifier"),
            AnyNode::OutputIdentifierInterface(_) => write!(f, "OutputIdentifierInterface"),
            AnyNode::LoopStatement(_) => write!(f, "LoopStatement"),
            AnyNode::LoopStatementForever(_) => write!(f, "LoopStatementForever"),
            AnyNode::LoopStatementRepeat(_) => write!(f, "LoopStatementRepeat"),
            AnyNode::LoopStatementWhile(_) => write!(f, "LoopStatementWhile"),
            AnyNode::LoopStatementFor(_) => write!(f, "LoopStatementFor"),
            AnyNode::LoopStatementDoWhile(_) => write!(f, "LoopStatementDoWhile"),
            AnyNode::LoopStatementForeach(_) => write!(f, "LoopStatementForeach"),
            AnyNode::ForInitialization(_) => write!(f, "ForInitialization"),
            AnyNode::ForInitializationDeclaration(_) => write!(f, "ForInitializationDeclaration"),
            AnyNode::ForVariableDeclaration(_) => write!(f, "ForVariableDeclaration"),
            AnyNode::Var(_) => write!(f, "Var"),
            AnyNode::ForStep(_) => write!(f, "ForStep"),
            AnyNode::ForStepAssignment(_) => write!(f, "ForStepAssignment"),
            AnyNode::LoopVariables(_) => write!(f, "LoopVariables"),
            AnyNode::CaseStatement(_) => write!(f, "CaseStatement"),
            AnyNode::CaseStatementNormal(_) => write!(f, "CaseStatementNormal"),
            AnyNode::CaseStatementMatches(_) => write!(f, "CaseStatementMatches"),
            AnyNode::CaseStatementInside(_) => write!(f, "CaseStatementInside"),
            AnyNode::CaseKeyword(_) => write!(f, "CaseKeyword"),
            AnyNode::CaseExpression(_) => write!(f, "CaseExpression"),
            AnyNode::CaseItem(_) => write!(f, "CaseItem"),
            AnyNode::CaseItemNondefault(_) => write!(f, "CaseItemNondefault"),
            AnyNode::CaseItemDefault(_) => write!(f, "CaseItemDefault"),
            AnyNode::CasePatternItem(_) => write!(f, "CasePatternItem"),
            AnyNode::CasePatternItemNondefault(_) => write!(f, "CasePatternItemNondefault"),
            AnyNode::CaseInsideItem(_) => write!(f, "CaseInsideItem"),
            AnyNode::CaseInsideItemNondefault(_) => write!(f, "CaseInsideItemNondefault"),
            AnyNode::CaseItemExpression(_) => write!(f, "CaseItemExpression"),
            AnyNode::RandcaseStatement(_) => write!(f, "RandcaseStatement"),
            AnyNode::RandcaseItem(_) => write!(f, "RandcaseItem"),
            AnyNode::OpenRangeList(_) => write!(f, "OpenRangeList"),
            AnyNode::OpenValueRange(_) => write!(f, "OpenValueRange"),
            AnyNode::ContinuousAssign(_) => write!(f, "ContinuousAssign"),
            AnyNode::ContinuousAssignNet(_) => write!(f, "ContinuousAssignNet"),
            AnyNode::ContinuousAssignVariable(_) => write!(f, "ContinuousAssignVariable"),
            AnyNode::ListOfNetAssignments(_) => write!(f, "ListOfNetAssignments"),
            AnyNode::ListOfVariableAssignments(_) => write!(f, "ListOfVariableAssignments"),
            AnyNode::NetAlias(_) => write!(f, "NetAlias"),
            AnyNode::NetAssignment(_) => write!(f, "NetAssignment"),
            AnyNode::ConditionalStatement(_) => write!(f, "ConditionalStatement"),
            AnyNode::UniquePriority(_) => write!(f, "UniquePriority"),
            AnyNode::CondPredicate(_) => write!(f, "CondPredicate"),
            AnyNode::ExpressionOrCondPattern(_) => write!(f, "ExpressionOrCondPattern"),
            AnyNode::CondPattern(_) => write!(f, "CondPattern"),
            AnyNode::ProceduralTimingControlStatement(_) => write!(f, "ProceduralTimingControlStatement"),
            AnyNode::DelayOrEventControl(_) => write!(f, "DelayOrEventControl"),
            AnyNode::DelayOrEventControlRepeat(_) => write!(f, "DelayOrEventControlRepeat"),
            AnyNode::DelayControl(_) => write!(f, "DelayControl"),
            AnyNode::DelayControlDelay(_) => write!(f, "DelayControlDelay"),
            AnyNode::DelayControlMintypmax(_) => write!(f, "DelayControlMintypmax"),
            AnyNode::EventControl(_) => write!(f, "EventControl"),
            AnyNode::EventControlEventIdentifier(_) => write!(f, "EventControlEventIdentifier"),
            AnyNode::EventControlEventExpression(_) => write!(f, "EventControlEventExpression"),
            AnyNode::EventControlAsterisk(_) => write!(f, "EventControlAsterisk"),
            AnyNode::EventControlParenAsterisk(_) => write!(f, "EventControlParenAsterisk"),
            AnyNode::EventControlSequenceIdentifier(_) => write!(f, "EventControlSequenceIdentifier"),
            AnyNode::EventExpression(_) => write!(f, "EventExpression"),
            AnyNode::EventExpressionExpression(_) => write!(f, "EventExpressionExpression"),
            AnyNode::EventExpressionSequence(_) => write!(f, "EventExpressionSequence"),
            AnyNode::EventExpressionOr(_) => write!(f, "EventExpressionOr"),
            AnyNode::EventExpressionComma(_) => write!(f, "EventExpressionComma"),
            AnyNode::EventExpressionParen(_) => write!(f, "EventExpressionParen"),
            AnyNode::ProceduralTimingControl(_) => write!(f, "ProceduralTimingControl"),
            AnyNode::JumpStatement(_) => write!(f, "JumpStatement"),
            AnyNode::JumpStatementReturn(_) => write!(f, "JumpStatementReturn"),
            AnyNode::JumpStatementBreak(_) => write!(f, "JumpStatementBreak"),
            AnyNode::JumpStatementContinue(_) => write!(f, "JumpStatementContinue"),
            AnyNode::WaitStatement(_) => write!(f, "WaitStatement"),
            AnyNode::WaitStatementWait(_) => write!(f, "WaitStatementWait"),
            AnyNode::WaitStatementFork(_) => write!(f, "WaitStatementFork"),
            AnyNode::WaitStatementOrder(_) => write!(f, "WaitStatementOrder"),
            AnyNode::EventTrigger(_) => write!(f, "EventTrigger"),
            AnyNode::EventTriggerNamed(_) => write!(f, "EventTriggerNamed"),
            AnyNode::EventTriggerNonblocking(_) => write!(f, "EventTriggerNonblocking"),
            AnyNode::DisableStatement(_) => write!(f, "DisableStatement"),
            AnyNode::DisableStatementTask(_) => write!(f, "DisableStatementTask"),
            AnyNode::DisableStatementBlock(_) => write!(f, "DisableStatementBlock"),
            AnyNode::DisableStatementFork(_) => write!(f, "DisableStatementFork"),
            AnyNode::RandsequenceStatement(_) => write!(f, "RandsequenceStatement"),
            AnyNode::Production(_) => write!(f, "Production"),
            AnyNode::RsRule(_) => write!(f, "RsRule"),
            AnyNode::RsProductionList(_) => write!(f, "RsProductionList"),
            AnyNode::RsProductionListProd(_) => write!(f, "RsProductionListProd"),
            AnyNode::RsProductionListJoin(_) => write!(f, "RsProductionListJoin"),
            AnyNode::WeightSpecification(_) => write!(f, "WeightSpecification"),
            AnyNode::WeightSpecificationExpression(_) => write!(f, "WeightSpecificationExpression"),
            AnyNode::RsCodeBlock(_) => write!(f, "RsCodeBlock"),
            AnyNode::RsProd(_) => write!(f, "RsProd"),
            AnyNode::ProductionItem(_) => write!(f, "ProductionItem"),
            AnyNode::RsIfElse(_) => write!(f, "RsIfElse"),
            AnyNode::RsRepeat(_) => write!(f, "RsRepeat"),
            AnyNode::RsCase(_) => write!(f, "RsCase"),
            AnyNode::RsCaseItem(_) => write!(f, "RsCaseItem"),
            AnyNode::RsCaseItemNondefault(_) => write!(f, "RsCaseItemNondefault"),
            AnyNode::RsCaseItemDefault(_) => write!(f, "RsCaseItemDefault"),
            AnyNode::Pattern(_) => write!(f, "Pattern"),
            AnyNode::PatternVariable(_) => write!(f, "PatternVariable"),
            AnyNode::PatternTagged(_) => write!(f, "PatternTagged"),
            AnyNode::PatternList(_) => write!(f, "PatternList"),
            AnyNode::PatternIdentifierList(_) => write!(f, "PatternIdentifierList"),
            AnyNode::AssignmentPattern(_) => write!(f, "AssignmentPattern"),
            AnyNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"),
            AnyNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"),
            AnyNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"),
            AnyNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"),
            AnyNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"),
            AnyNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"),
            AnyNode::AssignmentPatternKey(_) => write!(f, "AssignmentPatternKey"),
            AnyNode::AssignmentPatternExpression(_) => write!(f, "AssignmentPatternExpression"),
            AnyNode::AssignmentPatternExpressionType(_) => write!(f, "AssignmentPatternExpressionType"),
            AnyNode::ConstantAssignmentPatternExpression(_) => write!(f, "ConstantAssignmentPatternExpression"),
            AnyNode::AssignmentPatternNetLvalue(_) => write!(f, "AssignmentPatternNetLvalue"),
            AnyNode::AssignmentPatternVariableLvalue(_) => write!(f, "AssignmentPatternVariableLvalue"),
            AnyNode::AssertionItem(_) => write!(f, "AssertionItem"),
            AnyNode::DeferredImmediateAssetionItem(_) => write!(f, "DeferredImmediateAssetionItem"),
            AnyNode::ProceduralAssertionStatement(_) => write!(f, "ProceduralAssertionStatement"),
            AnyNode::ImmediateAssetionStatement(_) => write!(f, "ImmediateAssetionStatement"),
            AnyNode::SimpleImmediateAssertionStatement(_) => write!(f, "SimpleImmediateAssertionStatement"),
            AnyNode::SimpleImmediateAssertStatement(_) => write!(f, "SimpleImmediateAssertStatement"),
            AnyNode::SimpleImmediateAssumeStatement(_) => write!(f, "SimpleImmediateAssumeStatement"),
            AnyNode::SimpleImmediateCoverStatement(_) => write!(f, "SimpleImmediateCoverStatement"),
            AnyNode::DeferredImmediateAssertionStatement(_) => write!(f, "DeferredImmediateAssertionStatement"),
            AnyNode::DeferredImmediateAssertStatement(_) => write!(f, "DeferredImmediateAssertStatement"),
            AnyNode::DeferredImmediateAssumeStatement(_) => write!(f, "DeferredImmediateAssumeStatement"),
            AnyNode::DeferredImmediateCoverStatement(_) => write!(f, "DeferredImmediateCoverStatement"),
            AnyNode::AssertTiming(_) => write!(f, "AssertTiming"),
            AnyNode::InitialConstruct(_) => write!(f, "InitialConstruct"),
            AnyNode::AlwaysConstruct(_) => write!(f, "AlwaysConstruct"),
            AnyNode::AlwaysKeyword(_) => write!(f, "AlwaysKeyword"),
            AnyNode::FinalConstruct(_) => write!(f, "FinalConstruct"),
            AnyNode::BlockingAssignment(_) => write!(f, "BlockingAssignment"),
            AnyNode::BlockingAssignmentVariable(_) => write!(f, "BlockingAssignmentVariable"),
            AnyNode::BlockingAssignmentNonrangeVariable(_) => write!(f, "BlockingAssignmentNonrangeVariable"),
            AnyNode::BlockingAssignmentHierarchicalVariable(_) => write!(f, "BlockingAssignmentHierarchicalVariable"),
            AnyNode::OperatorAssignment(_) => write!(f, "OperatorAssignment"),
            AnyNode::AssignmentOperator(_) => write!(f, "AssignmentOperator"),
            AnyNode::NonblockingAssignment(_) => write!(f, "NonblockingAssignment"),
            AnyNode::ProceduralContinuousAssignment(_) => write!(f, "ProceduralContinuousAssignment"),
            AnyNode::ProceduralContinuousAssignmentAssign(_) => write!(f, "ProceduralContinuousAssignmentAssign"),
            AnyNode::ProceduralContinuousAssignmentDeassign(_) => write!(f, "ProceduralContinuousAssignmentDeassign"),
            AnyNode::ProceduralContinuousAssignmentForceVariable(_) => write!(f, "ProceduralContinuousAssignmentForceVariable"),
            AnyNode::ProceduralContinuousAssignmentForceNet(_) => write!(f, "ProceduralContinuousAssignmentForceNet"),
            AnyNode::ProceduralContinuousAssignmentReleaseVariable(_) => write!(f, "ProceduralContinuousAssignmentReleaseVariable"),
            AnyNode::ProceduralContinuousAssignmentReleaseNet(_) => write!(f, "ProceduralContinuousAssignmentReleaseNet"),
            AnyNode::VariableAssignment(_) => write!(f, "VariableAssignment"),
            AnyNode::SubroutineCallStatement(_) => write!(f, "SubroutineCallStatement"),
            AnyNode::SubroutineCallStatementFunction(_) => write!(f, "SubroutineCallStatementFunction"),
            AnyNode::ClockingDeclaration(_) => write!(f, "ClockingDeclaration"),
            AnyNode::ClockingDeclarationLocal(_) => write!(f, "ClockingDeclarationLocal"),
            AnyNode::Default(_) => write!(f, "Default"),
            AnyNode::ClockingDeclarationGlobal(_) => write!(f, "ClockingDeclarationGlobal"),
            AnyNode::ClockingEvent(_) => write!(f, "ClockingEvent"),
            AnyNode::ClockingEventIdentifier(_) => write!(f, "ClockingEventIdentifier"),
            AnyNode::ClockingEventExpression(_) => write!(f, "ClockingEventExpression"),
            AnyNode::ClockingItem(_) => write!(f, "ClockingItem"),
            AnyNode::ClockingItemDefault(_) => write!(f, "ClockingItemDefault"),
            AnyNode::ClockingItemDirection(_) => write!(f, "ClockingItemDirection"),
            AnyNode::ClockingItemAssertion(_) => write!(f, "ClockingItemAssertion"),
            AnyNode::DefaultSkew(_) => write!(f, "DefaultSkew"),
            AnyNode::DefaultSkewInput(_) => write!(f, "DefaultSkewInput"),
            AnyNode::DefaultSkewOutput(_) => write!(f, "DefaultSkewOutput"),
            AnyNode::DefaultSkewInputOutput(_) => write!(f, "DefaultSkewInputOutput"),
            AnyNode::ClockingDirection(_) => write!(f, "ClockingDirection"),
            AnyNode::ClockingDirectionInput(_) => write!(f, "ClockingDirectionInput"),
            AnyNode::ClockingDirectionOutput(_) => write!(f, "ClockingDirectionOutput"),
            AnyNode::ClockingDirectionInputOutput(_) => write!(f, "ClockingDirectionInputOutput"),
            AnyNode::ListOfClockingDeclAssign(_) => write!(f, "ListOfClockingDeclAssign"),
            AnyNode::ClockingDeclAssign(_) => write!(f, "ClockingDeclAssign"),
            AnyNode::ClockingSkew(_) => write!(f, "ClockingSkew"),
            AnyNode::ClockingSkewEdge(_) => write!(f, "ClockingSkewEdge"),
            AnyNode::ClockingDrive(_) => write!(f, "ClockingDrive"),
            AnyNode::CycleDelay(_) => write!(f, "CycleDelay"),
            AnyNode::CycleDelayIntegral(_) => write!(f, "CycleDelayIntegral"),
            AnyNode::CycleDelayIdentifier(_) => write!(f, "CycleDelayIdentifier"),
            AnyNode::CycleDelayExpression(_) => write!(f, "CycleDelayExpression"),
            AnyNode::Clockvar(_) => write!(f, "Clockvar"),
            AnyNode::ClockvarExpression(_) => write!(f, "ClockvarExpression"),
            AnyNode::ActionBlock(_) => write!(f, "ActionBlock"),
            AnyNode::ActionBlockElse(_) => write!(f, "ActionBlockElse"),
            AnyNode::SeqBlock(_) => write!(f, "SeqBlock"),
            AnyNode::ParBlock(_) => write!(f, "ParBlock"),
            AnyNode::JoinKeyword(_) => write!(f, "JoinKeyword"),
            AnyNode::StatementOrNull(_) => write!(f, "StatementOrNull"),
            AnyNode::StatementOrNullAttribute(_) => write!(f, "StatementOrNullAttribute"),
            AnyNode::Statement(_) => write!(f, "Statement"),
            AnyNode::StatementItem(_) => write!(f, "StatementItem"),
            AnyNode::FunctionStatement(_) => write!(f, "FunctionStatement"),
            AnyNode::FunctionStatementOrNull(_) => write!(f, "FunctionStatementOrNull"),
            AnyNode::FunctionStatementOrNullAttribute(_) => write!(f, "FunctionStatementOrNullAttribute"),
            AnyNode::VariableIdentifierList(_) => write!(f, "VariableIdentifierList"),
            AnyNode::UdpInstantiation(_) => write!(f, "UdpInstantiation"),
            AnyNode::UdpInstance(_) => write!(f, "UdpInstance"),
            AnyNode::UdpNonansiDeclaration(_) => write!(f, "UdpNonansiDeclaration"),
            AnyNode::UdpAnsiDeclaration(_) => write!(f, "UdpAnsiDeclaration"),
            AnyNode::UdpDeclaration(_) => write!(f, "UdpDeclaration"),
            AnyNode::UdpDeclarationNonansi(_) => write!(f, "UdpDeclarationNonansi"),
            AnyNode::UdpDeclarationAnsi(_) => write!(f, "UdpDeclarationAnsi"),
            AnyNode::UdpDeclarationExternNonansi(_) => write!(f, "UdpDeclarationExternNonansi"),
            AnyNode::UdpDeclarationExternAnsi(_) => write!(f, "UdpDeclarationExternAnsi"),
            AnyNode::UdpDeclarationWildcard(_) => write!(f, "UdpDeclarationWildcard"),
            AnyNode::UdpBody(_) => write!(f, "UdpBody"),
            AnyNode::CombinationalBody(_) => write!(f, "CombinationalBody"),
            AnyNode::CombinationalEntry(_) => write!(f, "CombinationalEntry"),
            AnyNode::SequentialBody(_) => write!(f, "SequentialBody"),
            AnyNode::UdpInitialStatement(_) => write!(f, "UdpInitialStatement"),
            AnyNode::InitVal(_) => write!(f, "InitVal"),
            AnyNode::SequentialEntry(_) => write!(f, "SequentialEntry"),
            AnyNode::SeqInputList(_) => write!(f, "SeqInputList"),
            AnyNode::LevelInputList(_) => write!(f, "LevelInputList"),
            AnyNode::EdgeInputList(_) => write!(f, "EdgeInputList"),
            AnyNode::EdgeIndicator(_) => write!(f, "EdgeIndicator"),
            AnyNode::EdgeIndicatorParen(_) => write!(f, "EdgeIndicatorParen"),
            AnyNode::CurrentState(_) => write!(f, "CurrentState"),
            AnyNode::NextState(_) => write!(f, "NextState"),
            AnyNode::OutputSymbol(_) => write!(f, "OutputSymbol"),
            AnyNode::LevelSymbol(_) => write!(f, "LevelSymbol"),
            AnyNode::EdgeSymbol(_) => write!(f, "EdgeSymbol"),
            AnyNode::UdpPortList(_) => write!(f, "UdpPortList"),
            AnyNode::UdpDeclarationPortList(_) => write!(f, "UdpDeclarationPortList"),
            AnyNode::UdpPortDeclaration(_) => write!(f, "UdpPortDeclaration"),
            AnyNode::UdpOutputDeclaration(_) => write!(f, "UdpOutputDeclaration"),
            AnyNode::UdpOutputDeclarationNonreg(_) => write!(f, "UdpOutputDeclarationNonreg"),
            AnyNode::UdpOutputDeclarationReg(_) => write!(f, "UdpOutputDeclarationReg"),
            AnyNode::UdpInputDeclaration(_) => write!(f, "UdpInputDeclaration"),
            AnyNode::UdpRegDeclaration(_) => write!(f, "UdpRegDeclaration"),
            AnyNode::InterfaceInstantiation(_) => write!(f, "InterfaceInstantiation"),
            AnyNode::CheckerInstantiation(_) => write!(f, "CheckerInstantiation"),
            AnyNode::ListOfCheckerPortConnections(_) => write!(f, "ListOfCheckerPortConnections"),
            AnyNode::ListOfCheckerPortConnectionsOrdered(_) => write!(f, "ListOfCheckerPortConnectionsOrdered"),
            AnyNode::ListOfCheckerPortConnectionsNamed(_) => write!(f, "ListOfCheckerPortConnectionsNamed"),
            AnyNode::OrderedCheckerPortConnection(_) => write!(f, "OrderedCheckerPortConnection"),
            AnyNode::NamedCheckerPortConnection(_) => write!(f, "NamedCheckerPortConnection"),
            AnyNode::NamedCheckerPortConnectionIdentifier(_) => write!(f, "NamedCheckerPortConnectionIdentifier"),
            AnyNode::NamedCheckerPortConnectionAsterisk(_) => write!(f, "NamedCheckerPortConnectionAsterisk"),
            AnyNode::ModuleInstantiation(_) => write!(f, "ModuleInstantiation"),
            AnyNode::ParameterValueAssignment(_) => write!(f, "ParameterValueAssignment"),
            AnyNode::ListOfParameterAssignments(_) => write!(f, "ListOfParameterAssignments"),
            AnyNode::ListOfParameterAssignmentsOrdered(_) => write!(f, "ListOfParameterAssignmentsOrdered"),
            AnyNode::ListOfParameterAssignmentsNamed(_) => write!(f, "ListOfParameterAssignmentsNamed"),
            AnyNode::OrderedParameterAssignment(_) => write!(f, "OrderedParameterAssignment"),
            AnyNode::NamedParameterAssignment(_) => write!(f, "NamedParameterAssignment"),
            AnyNode::HierarchicalInstance(_) => write!(f, "HierarchicalInstance"),
            AnyNode::NameOfInstance(_) => write!(f, "NameOfInstance"),
            AnyNode::ListOfPortConnections(_) => write!(f, "ListOfPortConnections"),
            AnyNode::ListOfPortConnectionsOrdered(_) => write!(f, "ListOfPortConnectionsOrdered"),
            AnyNode::ListOfPortConnectionsNamed(_) => write!(f, "ListOfPortConnectionsNamed"),
            AnyNode::OrderedPortConnection(_) => write!(f, "OrderedPortConnection"),
            AnyNode::NamedPortConnection(_) => write!(f, "NamedPortConnection"),
            AnyNode::NamedPortConnectionIdentifier(_) => write!(f, "NamedPortConnectionIdentifier"),
            AnyNode::NamedPortConnectionAsterisk(_) => write!(f, "NamedPortConnectionAsterisk"),
            AnyNode::ProgramInstantiation(_) => write!(f, "ProgramInstantiation"),
            AnyNode::GenerateRegion(_) => write!(f, "GenerateRegion"),
            AnyNode::LoopGenerateConstruct(_) => write!(f, "LoopGenerateConstruct"),
            AnyNode::GenvarInitialization(_) => write!(f, "GenvarInitialization"),
            AnyNode::Genvar(_) => write!(f, "Genvar"),
            AnyNode::GenvarIteration(_) => write!(f, "GenvarIteration"),
            AnyNode::GenvarIterationAssignment(_) => write!(f, "GenvarIterationAssignment"),
            AnyNode::GenvarIterationPrefix(_) => write!(f, "GenvarIterationPrefix"),
            AnyNode::GenvarIterationSuffix(_) => write!(f, "GenvarIterationSuffix"),
            AnyNode::ConditionalGenerateConstruct(_) => write!(f, "ConditionalGenerateConstruct"),
            AnyNode::IfGenerateConstruct(_) => write!(f, "IfGenerateConstruct"),
            AnyNode::CaseGenerateConstruct(_) => write!(f, "CaseGenerateConstruct"),
            AnyNode::CaseGenerateItem(_) => write!(f, "CaseGenerateItem"),
            AnyNode::CaseGenerateItemNondefault(_) => write!(f, "CaseGenerateItemNondefault"),
            AnyNode::CaseGenerateItemDefault(_) => write!(f, "CaseGenerateItemDefault"),
            AnyNode::GenerateBlock(_) => write!(f, "GenerateBlock"),
            AnyNode::GenerateBlockMultiple(_) => write!(f, "GenerateBlockMultiple"),
            AnyNode::GenerateItem(_) => write!(f, "GenerateItem"),

        }
    }
}