// Generated by astgen // -*- mode: C++; c-file-style: "cc-mode" -*-
// For internal use. They assume argument is not nullptr.
template<> inline bool AstNode::privateTypeTest<AstAbortOn>(const AstNode* nodep) { return nodep->type() == VNType::AbortOn; }
template<> inline bool AstNode::privateTypeTest<AstAcosD>(const AstNode* nodep) { return nodep->type() == VNType::AcosD; }
template<> inline bool AstNode::privateTypeTest<AstAcoshD>(const AstNode* nodep) { return nodep->type() == VNType::AcoshD; }
template<> inline bool AstNode::privateTypeTest<AstActive>(const AstNode* nodep) { return nodep->type() == VNType::Active; }
template<> inline bool AstNode::privateTypeTest<AstAdd>(const AstNode* nodep) { return nodep->type() == VNType::Add; }
template<> inline bool AstNode::privateTypeTest<AstAddD>(const AstNode* nodep) { return nodep->type() == VNType::AddD; }
template<> inline bool AstNode::privateTypeTest<AstAddrOfCFunc>(const AstNode* nodep) { return nodep->type() == VNType::AddrOfCFunc; }
template<> inline bool AstNode::privateTypeTest<AstAlias>(const AstNode* nodep) { return nodep->type() == VNType::Alias; }
template<> inline bool AstNode::privateTypeTest<AstAliasScope>(const AstNode* nodep) { return nodep->type() == VNType::AliasScope; }
template<> inline bool AstNode::privateTypeTest<AstAlways>(const AstNode* nodep) { return nodep->type() == VNType::Always; }
template<> inline bool AstNode::privateTypeTest<AstAlwaysObserved>(const AstNode* nodep) { return nodep->type() == VNType::AlwaysObserved; }
template<> inline bool AstNode::privateTypeTest<AstAlwaysPost>(const AstNode* nodep) { return nodep->type() == VNType::AlwaysPost; }
template<> inline bool AstNode::privateTypeTest<AstAlwaysPostponed>(const AstNode* nodep) { return nodep->type() == VNType::AlwaysPostponed; }
template<> inline bool AstNode::privateTypeTest<AstAlwaysPre>(const AstNode* nodep) { return nodep->type() == VNType::AlwaysPre; }
template<> inline bool AstNode::privateTypeTest<AstAlwaysReactive>(const AstNode* nodep) { return nodep->type() == VNType::AlwaysReactive; }
template<> inline bool AstNode::privateTypeTest<AstAnd>(const AstNode* nodep) { return nodep->type() == VNType::And; }
template<> inline bool AstNode::privateTypeTest<AstArg>(const AstNode* nodep) { return nodep->type() == VNType::Arg; }
template<> inline bool AstNode::privateTypeTest<AstArraySel>(const AstNode* nodep) { return nodep->type() == VNType::ArraySel; }
template<> inline bool AstNode::privateTypeTest<AstAsinD>(const AstNode* nodep) { return nodep->type() == VNType::AsinD; }
template<> inline bool AstNode::privateTypeTest<AstAsinhD>(const AstNode* nodep) { return nodep->type() == VNType::AsinhD; }
template<> inline bool AstNode::privateTypeTest<AstAssert>(const AstNode* nodep) { return nodep->type() == VNType::Assert; }
template<> inline bool AstNode::privateTypeTest<AstAssertCtl>(const AstNode* nodep) { return nodep->type() == VNType::AssertCtl; }
template<> inline bool AstNode::privateTypeTest<AstAssertIntrinsic>(const AstNode* nodep) { return nodep->type() == VNType::AssertIntrinsic; }
template<> inline bool AstNode::privateTypeTest<AstAssign>(const AstNode* nodep) { return nodep->type() == VNType::Assign; }
template<> inline bool AstNode::privateTypeTest<AstAssignCompound>(const AstNode* nodep) { return nodep->type() == VNType::AssignCompound; }
template<> inline bool AstNode::privateTypeTest<AstAssignCont>(const AstNode* nodep) { return nodep->type() == VNType::AssignCont; }
template<> inline bool AstNode::privateTypeTest<AstAssignDly>(const AstNode* nodep) { return nodep->type() == VNType::AssignDly; }
template<> inline bool AstNode::privateTypeTest<AstAssignForce>(const AstNode* nodep) { return nodep->type() == VNType::AssignForce; }
template<> inline bool AstNode::privateTypeTest<AstAssignW>(const AstNode* nodep) { return nodep->type() == VNType::AssignW; }
template<> inline bool AstNode::privateTypeTest<AstAssocArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::AssocArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstAssocSel>(const AstNode* nodep) { return nodep->type() == VNType::AssocSel; }
template<> inline bool AstNode::privateTypeTest<AstAtan2D>(const AstNode* nodep) { return nodep->type() == VNType::Atan2D; }
template<> inline bool AstNode::privateTypeTest<AstAtanD>(const AstNode* nodep) { return nodep->type() == VNType::AtanD; }
template<> inline bool AstNode::privateTypeTest<AstAtanhD>(const AstNode* nodep) { return nodep->type() == VNType::AtanhD; }
template<> inline bool AstNode::privateTypeTest<AstAtoN>(const AstNode* nodep) { return nodep->type() == VNType::AtoN; }
template<> inline bool AstNode::privateTypeTest<AstAttrOf>(const AstNode* nodep) { return nodep->type() == VNType::AttrOf; }
template<> inline bool AstNode::privateTypeTest<AstBasicDType>(const AstNode* nodep) { return nodep->type() == VNType::BasicDType; }
template<> inline bool AstNode::privateTypeTest<AstBegin>(const AstNode* nodep) { return nodep->type() == VNType::Begin; }
template<> inline bool AstNode::privateTypeTest<AstBind>(const AstNode* nodep) { return nodep->type() == VNType::Bind; }
template<> inline bool AstNode::privateTypeTest<AstBitsToRealD>(const AstNode* nodep) { return nodep->type() == VNType::BitsToRealD; }
template<> inline bool AstNode::privateTypeTest<AstBracketArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::BracketArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstBracketRange>(const AstNode* nodep) { return nodep->type() == VNType::BracketRange; }
template<> inline bool AstNode::privateTypeTest<AstBreak>(const AstNode* nodep) { return nodep->type() == VNType::Break; }
template<> inline bool AstNode::privateTypeTest<AstBufIf1>(const AstNode* nodep) { return nodep->type() == VNType::BufIf1; }
template<> inline bool AstNode::privateTypeTest<AstCAwait>(const AstNode* nodep) { return nodep->type() == VNType::CAwait; }
template<> inline bool AstNode::privateTypeTest<AstCCall>(const AstNode* nodep) { return nodep->type() == VNType::CCall; }
template<> inline bool AstNode::privateTypeTest<AstCCast>(const AstNode* nodep) { return nodep->type() == VNType::CCast; }
template<> inline bool AstNode::privateTypeTest<AstCDType>(const AstNode* nodep) { return nodep->type() == VNType::CDType; }
template<> inline bool AstNode::privateTypeTest<AstCExpr>(const AstNode* nodep) { return nodep->type() == VNType::CExpr; }
template<> inline bool AstNode::privateTypeTest<AstCExprUser>(const AstNode* nodep) { return nodep->type() == VNType::CExprUser; }
template<> inline bool AstNode::privateTypeTest<AstCFile>(const AstNode* nodep) { return nodep->type() == VNType::CFile; }
template<> inline bool AstNode::privateTypeTest<AstCFunc>(const AstNode* nodep) { return nodep->type() == VNType::CFunc; }
template<> inline bool AstNode::privateTypeTest<AstCLocalScope>(const AstNode* nodep) { return nodep->type() == VNType::CLocalScope; }
template<> inline bool AstNode::privateTypeTest<AstCLog2>(const AstNode* nodep) { return nodep->type() == VNType::CLog2; }
template<> inline bool AstNode::privateTypeTest<AstCMethodCall>(const AstNode* nodep) { return nodep->type() == VNType::CMethodCall; }
template<> inline bool AstNode::privateTypeTest<AstCMethodHard>(const AstNode* nodep) { return nodep->type() == VNType::CMethodHard; }
template<> inline bool AstNode::privateTypeTest<AstCNew>(const AstNode* nodep) { return nodep->type() == VNType::CNew; }
template<> inline bool AstNode::privateTypeTest<AstCReset>(const AstNode* nodep) { return nodep->type() == VNType::CReset; }
template<> inline bool AstNode::privateTypeTest<AstCReturn>(const AstNode* nodep) { return nodep->type() == VNType::CReturn; }
template<> inline bool AstNode::privateTypeTest<AstCStmt>(const AstNode* nodep) { return nodep->type() == VNType::CStmt; }
template<> inline bool AstNode::privateTypeTest<AstCStmtUser>(const AstNode* nodep) { return nodep->type() == VNType::CStmtUser; }
template<> inline bool AstNode::privateTypeTest<AstCUse>(const AstNode* nodep) { return nodep->type() == VNType::CUse; }
template<> inline bool AstNode::privateTypeTest<AstCase>(const AstNode* nodep) { return nodep->type() == VNType::Case; }
template<> inline bool AstNode::privateTypeTest<AstCaseItem>(const AstNode* nodep) { return nodep->type() == VNType::CaseItem; }
template<> inline bool AstNode::privateTypeTest<AstCast>(const AstNode* nodep) { return nodep->type() == VNType::Cast; }
template<> inline bool AstNode::privateTypeTest<AstCastDynamic>(const AstNode* nodep) { return nodep->type() == VNType::CastDynamic; }
template<> inline bool AstNode::privateTypeTest<AstCastParse>(const AstNode* nodep) { return nodep->type() == VNType::CastParse; }
template<> inline bool AstNode::privateTypeTest<AstCastSize>(const AstNode* nodep) { return nodep->type() == VNType::CastSize; }
template<> inline bool AstNode::privateTypeTest<AstCastWrap>(const AstNode* nodep) { return nodep->type() == VNType::CastWrap; }
template<> inline bool AstNode::privateTypeTest<AstCeilD>(const AstNode* nodep) { return nodep->type() == VNType::CeilD; }
template<> inline bool AstNode::privateTypeTest<AstCell>(const AstNode* nodep) { return nodep->type() == VNType::Cell; }
template<> inline bool AstNode::privateTypeTest<AstCellArrayRef>(const AstNode* nodep) { return nodep->type() == VNType::CellArrayRef; }
template<> inline bool AstNode::privateTypeTest<AstCellInline>(const AstNode* nodep) { return nodep->type() == VNType::CellInline; }
template<> inline bool AstNode::privateTypeTest<AstCellInlineScope>(const AstNode* nodep) { return nodep->type() == VNType::CellInlineScope; }
template<> inline bool AstNode::privateTypeTest<AstCellRef>(const AstNode* nodep) { return nodep->type() == VNType::CellRef; }
template<> inline bool AstNode::privateTypeTest<AstCgOptionAssign>(const AstNode* nodep) { return nodep->type() == VNType::CgOptionAssign; }
template<> inline bool AstNode::privateTypeTest<AstClass>(const AstNode* nodep) { return nodep->type() == VNType::Class; }
template<> inline bool AstNode::privateTypeTest<AstClassExtends>(const AstNode* nodep) { return nodep->type() == VNType::ClassExtends; }
template<> inline bool AstNode::privateTypeTest<AstClassOrPackageRef>(const AstNode* nodep) { return nodep->type() == VNType::ClassOrPackageRef; }
template<> inline bool AstNode::privateTypeTest<AstClassPackage>(const AstNode* nodep) { return nodep->type() == VNType::ClassPackage; }
template<> inline bool AstNode::privateTypeTest<AstClassRefDType>(const AstNode* nodep) { return nodep->type() == VNType::ClassRefDType; }
template<> inline bool AstNode::privateTypeTest<AstClocking>(const AstNode* nodep) { return nodep->type() == VNType::Clocking; }
template<> inline bool AstNode::privateTypeTest<AstClockingItem>(const AstNode* nodep) { return nodep->type() == VNType::ClockingItem; }
template<> inline bool AstNode::privateTypeTest<AstComment>(const AstNode* nodep) { return nodep->type() == VNType::Comment; }
template<> inline bool AstNode::privateTypeTest<AstCompareNN>(const AstNode* nodep) { return nodep->type() == VNType::CompareNN; }
template<> inline bool AstNode::privateTypeTest<AstConcat>(const AstNode* nodep) { return nodep->type() == VNType::Concat; }
template<> inline bool AstNode::privateTypeTest<AstConcatN>(const AstNode* nodep) { return nodep->type() == VNType::ConcatN; }
template<> inline bool AstNode::privateTypeTest<AstCond>(const AstNode* nodep) { return nodep->type() == VNType::Cond; }
template<> inline bool AstNode::privateTypeTest<AstConfig>(const AstNode* nodep) { return nodep->type() == VNType::Config; }
template<> inline bool AstNode::privateTypeTest<AstConfigCell>(const AstNode* nodep) { return nodep->type() == VNType::ConfigCell; }
template<> inline bool AstNode::privateTypeTest<AstConfigRule>(const AstNode* nodep) { return nodep->type() == VNType::ConfigRule; }
template<> inline bool AstNode::privateTypeTest<AstConfigUse>(const AstNode* nodep) { return nodep->type() == VNType::ConfigUse; }
template<> inline bool AstNode::privateTypeTest<AstConsAssoc>(const AstNode* nodep) { return nodep->type() == VNType::ConsAssoc; }
template<> inline bool AstNode::privateTypeTest<AstConsDynArray>(const AstNode* nodep) { return nodep->type() == VNType::ConsDynArray; }
template<> inline bool AstNode::privateTypeTest<AstConsPackMember>(const AstNode* nodep) { return nodep->type() == VNType::ConsPackMember; }
template<> inline bool AstNode::privateTypeTest<AstConsPackUOrStruct>(const AstNode* nodep) { return nodep->type() == VNType::ConsPackUOrStruct; }
template<> inline bool AstNode::privateTypeTest<AstConsQueue>(const AstNode* nodep) { return nodep->type() == VNType::ConsQueue; }
template<> inline bool AstNode::privateTypeTest<AstConsWildcard>(const AstNode* nodep) { return nodep->type() == VNType::ConsWildcard; }
template<> inline bool AstNode::privateTypeTest<AstConst>(const AstNode* nodep) { return nodep->type() == VNType::Const; }
template<> inline bool AstNode::privateTypeTest<AstConstDType>(const AstNode* nodep) { return nodep->type() == VNType::ConstDType; }
template<> inline bool AstNode::privateTypeTest<AstConstPool>(const AstNode* nodep) { return nodep->type() == VNType::ConstPool; }
template<> inline bool AstNode::privateTypeTest<AstConstraint>(const AstNode* nodep) { return nodep->type() == VNType::Constraint; }
template<> inline bool AstNode::privateTypeTest<AstConstraintBefore>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintBefore; }
template<> inline bool AstNode::privateTypeTest<AstConstraintExpr>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintExpr; }
template<> inline bool AstNode::privateTypeTest<AstConstraintForeach>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintForeach; }
template<> inline bool AstNode::privateTypeTest<AstConstraintIf>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintIf; }
template<> inline bool AstNode::privateTypeTest<AstConstraintRef>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintRef; }
template<> inline bool AstNode::privateTypeTest<AstConstraintRefDType>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintRefDType; }
template<> inline bool AstNode::privateTypeTest<AstConstraintUnique>(const AstNode* nodep) { return nodep->type() == VNType::ConstraintUnique; }
template<> inline bool AstNode::privateTypeTest<AstContinue>(const AstNode* nodep) { return nodep->type() == VNType::Continue; }
template<> inline bool AstNode::privateTypeTest<AstCosD>(const AstNode* nodep) { return nodep->type() == VNType::CosD; }
template<> inline bool AstNode::privateTypeTest<AstCoshD>(const AstNode* nodep) { return nodep->type() == VNType::CoshD; }
template<> inline bool AstNode::privateTypeTest<AstCountBits>(const AstNode* nodep) { return nodep->type() == VNType::CountBits; }
template<> inline bool AstNode::privateTypeTest<AstCountOnes>(const AstNode* nodep) { return nodep->type() == VNType::CountOnes; }
template<> inline bool AstNode::privateTypeTest<AstCover>(const AstNode* nodep) { return nodep->type() == VNType::Cover; }
template<> inline bool AstNode::privateTypeTest<AstCoverBin>(const AstNode* nodep) { return nodep->type() == VNType::CoverBin; }
template<> inline bool AstNode::privateTypeTest<AstCoverCross>(const AstNode* nodep) { return nodep->type() == VNType::CoverCross; }
template<> inline bool AstNode::privateTypeTest<AstCoverInc>(const AstNode* nodep) { return nodep->type() == VNType::CoverInc; }
template<> inline bool AstNode::privateTypeTest<AstCoverOption>(const AstNode* nodep) { return nodep->type() == VNType::CoverOption; }
template<> inline bool AstNode::privateTypeTest<AstCoverOtherDecl>(const AstNode* nodep) { return nodep->type() == VNType::CoverOtherDecl; }
template<> inline bool AstNode::privateTypeTest<AstCoverToggle>(const AstNode* nodep) { return nodep->type() == VNType::CoverToggle; }
template<> inline bool AstNode::privateTypeTest<AstCoverToggleDecl>(const AstNode* nodep) { return nodep->type() == VNType::CoverToggleDecl; }
template<> inline bool AstNode::privateTypeTest<AstCoverTransItem>(const AstNode* nodep) { return nodep->type() == VNType::CoverTransItem; }
template<> inline bool AstNode::privateTypeTest<AstCoverTransSet>(const AstNode* nodep) { return nodep->type() == VNType::CoverTransSet; }
template<> inline bool AstNode::privateTypeTest<AstCovergroup>(const AstNode* nodep) { return nodep->type() == VNType::Covergroup; }
template<> inline bool AstNode::privateTypeTest<AstCoverpoint>(const AstNode* nodep) { return nodep->type() == VNType::Coverpoint; }
template<> inline bool AstNode::privateTypeTest<AstCoverpointRef>(const AstNode* nodep) { return nodep->type() == VNType::CoverpointRef; }
template<> inline bool AstNode::privateTypeTest<AstCvtArrayToArray>(const AstNode* nodep) { return nodep->type() == VNType::CvtArrayToArray; }
template<> inline bool AstNode::privateTypeTest<AstCvtArrayToPacked>(const AstNode* nodep) { return nodep->type() == VNType::CvtArrayToPacked; }
template<> inline bool AstNode::privateTypeTest<AstCvtPackString>(const AstNode* nodep) { return nodep->type() == VNType::CvtPackString; }
template<> inline bool AstNode::privateTypeTest<AstCvtPackedToArray>(const AstNode* nodep) { return nodep->type() == VNType::CvtPackedToArray; }
template<> inline bool AstNode::privateTypeTest<AstCvtUnpackedToQueue>(const AstNode* nodep) { return nodep->type() == VNType::CvtUnpackedToQueue; }
template<> inline bool AstNode::privateTypeTest<AstDeassign>(const AstNode* nodep) { return nodep->type() == VNType::Deassign; }
template<> inline bool AstNode::privateTypeTest<AstDefImplicitDType>(const AstNode* nodep) { return nodep->type() == VNType::DefImplicitDType; }
template<> inline bool AstNode::privateTypeTest<AstDefParam>(const AstNode* nodep) { return nodep->type() == VNType::DefParam; }
template<> inline bool AstNode::privateTypeTest<AstDefaultDisable>(const AstNode* nodep) { return nodep->type() == VNType::DefaultDisable; }
template<> inline bool AstNode::privateTypeTest<AstDelay>(const AstNode* nodep) { return nodep->type() == VNType::Delay; }
template<> inline bool AstNode::privateTypeTest<AstDisable>(const AstNode* nodep) { return nodep->type() == VNType::Disable; }
template<> inline bool AstNode::privateTypeTest<AstDisableFork>(const AstNode* nodep) { return nodep->type() == VNType::DisableFork; }
template<> inline bool AstNode::privateTypeTest<AstDisplay>(const AstNode* nodep) { return nodep->type() == VNType::Display; }
template<> inline bool AstNode::privateTypeTest<AstDist>(const AstNode* nodep) { return nodep->type() == VNType::Dist; }
template<> inline bool AstNode::privateTypeTest<AstDistChiSquare>(const AstNode* nodep) { return nodep->type() == VNType::DistChiSquare; }
template<> inline bool AstNode::privateTypeTest<AstDistErlang>(const AstNode* nodep) { return nodep->type() == VNType::DistErlang; }
template<> inline bool AstNode::privateTypeTest<AstDistExponential>(const AstNode* nodep) { return nodep->type() == VNType::DistExponential; }
template<> inline bool AstNode::privateTypeTest<AstDistItem>(const AstNode* nodep) { return nodep->type() == VNType::DistItem; }
template<> inline bool AstNode::privateTypeTest<AstDistNormal>(const AstNode* nodep) { return nodep->type() == VNType::DistNormal; }
template<> inline bool AstNode::privateTypeTest<AstDistPoisson>(const AstNode* nodep) { return nodep->type() == VNType::DistPoisson; }
template<> inline bool AstNode::privateTypeTest<AstDistT>(const AstNode* nodep) { return nodep->type() == VNType::DistT; }
template<> inline bool AstNode::privateTypeTest<AstDistUniform>(const AstNode* nodep) { return nodep->type() == VNType::DistUniform; }
template<> inline bool AstNode::privateTypeTest<AstDiv>(const AstNode* nodep) { return nodep->type() == VNType::Div; }
template<> inline bool AstNode::privateTypeTest<AstDivD>(const AstNode* nodep) { return nodep->type() == VNType::DivD; }
template<> inline bool AstNode::privateTypeTest<AstDivS>(const AstNode* nodep) { return nodep->type() == VNType::DivS; }
template<> inline bool AstNode::privateTypeTest<AstDot>(const AstNode* nodep) { return nodep->type() == VNType::Dot; }
template<> inline bool AstNode::privateTypeTest<AstDpiExport>(const AstNode* nodep) { return nodep->type() == VNType::DpiExport; }
template<> inline bool AstNode::privateTypeTest<AstDumpCtl>(const AstNode* nodep) { return nodep->type() == VNType::DumpCtl; }
template<> inline bool AstNode::privateTypeTest<AstDynArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::DynArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstElabDisplay>(const AstNode* nodep) { return nodep->type() == VNType::ElabDisplay; }
template<> inline bool AstNode::privateTypeTest<AstEmpty>(const AstNode* nodep) { return nodep->type() == VNType::Empty; }
template<> inline bool AstNode::privateTypeTest<AstEmptyQueue>(const AstNode* nodep) { return nodep->type() == VNType::EmptyQueue; }
template<> inline bool AstNode::privateTypeTest<AstEmptyQueueDType>(const AstNode* nodep) { return nodep->type() == VNType::EmptyQueueDType; }
template<> inline bool AstNode::privateTypeTest<AstEnumDType>(const AstNode* nodep) { return nodep->type() == VNType::EnumDType; }
template<> inline bool AstNode::privateTypeTest<AstEnumItem>(const AstNode* nodep) { return nodep->type() == VNType::EnumItem; }
template<> inline bool AstNode::privateTypeTest<AstEnumItemRef>(const AstNode* nodep) { return nodep->type() == VNType::EnumItemRef; }
template<> inline bool AstNode::privateTypeTest<AstEq>(const AstNode* nodep) { return nodep->type() == VNType::Eq; }
template<> inline bool AstNode::privateTypeTest<AstEqCase>(const AstNode* nodep) { return nodep->type() == VNType::EqCase; }
template<> inline bool AstNode::privateTypeTest<AstEqD>(const AstNode* nodep) { return nodep->type() == VNType::EqD; }
template<> inline bool AstNode::privateTypeTest<AstEqN>(const AstNode* nodep) { return nodep->type() == VNType::EqN; }
template<> inline bool AstNode::privateTypeTest<AstEqT>(const AstNode* nodep) { return nodep->type() == VNType::EqT; }
template<> inline bool AstNode::privateTypeTest<AstEqWild>(const AstNode* nodep) { return nodep->type() == VNType::EqWild; }
template<> inline bool AstNode::privateTypeTest<AstEventControl>(const AstNode* nodep) { return nodep->type() == VNType::EventControl; }
template<> inline bool AstNode::privateTypeTest<AstExecGraph>(const AstNode* nodep) { return nodep->type() == VNType::ExecGraph; }
template<> inline bool AstNode::privateTypeTest<AstExpD>(const AstNode* nodep) { return nodep->type() == VNType::ExpD; }
template<> inline bool AstNode::privateTypeTest<AstExprStmt>(const AstNode* nodep) { return nodep->type() == VNType::ExprStmt; }
template<> inline bool AstNode::privateTypeTest<AstExtend>(const AstNode* nodep) { return nodep->type() == VNType::Extend; }
template<> inline bool AstNode::privateTypeTest<AstExtendS>(const AstNode* nodep) { return nodep->type() == VNType::ExtendS; }
template<> inline bool AstNode::privateTypeTest<AstFClose>(const AstNode* nodep) { return nodep->type() == VNType::FClose; }
template<> inline bool AstNode::privateTypeTest<AstFEof>(const AstNode* nodep) { return nodep->type() == VNType::FEof; }
template<> inline bool AstNode::privateTypeTest<AstFError>(const AstNode* nodep) { return nodep->type() == VNType::FError; }
template<> inline bool AstNode::privateTypeTest<AstFFlush>(const AstNode* nodep) { return nodep->type() == VNType::FFlush; }
template<> inline bool AstNode::privateTypeTest<AstFGetC>(const AstNode* nodep) { return nodep->type() == VNType::FGetC; }
template<> inline bool AstNode::privateTypeTest<AstFGetS>(const AstNode* nodep) { return nodep->type() == VNType::FGetS; }
template<> inline bool AstNode::privateTypeTest<AstFOpen>(const AstNode* nodep) { return nodep->type() == VNType::FOpen; }
template<> inline bool AstNode::privateTypeTest<AstFOpenMcd>(const AstNode* nodep) { return nodep->type() == VNType::FOpenMcd; }
template<> inline bool AstNode::privateTypeTest<AstFRead>(const AstNode* nodep) { return nodep->type() == VNType::FRead; }
template<> inline bool AstNode::privateTypeTest<AstFRewind>(const AstNode* nodep) { return nodep->type() == VNType::FRewind; }
template<> inline bool AstNode::privateTypeTest<AstFScanF>(const AstNode* nodep) { return nodep->type() == VNType::FScanF; }
template<> inline bool AstNode::privateTypeTest<AstFSeek>(const AstNode* nodep) { return nodep->type() == VNType::FSeek; }
template<> inline bool AstNode::privateTypeTest<AstFTell>(const AstNode* nodep) { return nodep->type() == VNType::FTell; }
template<> inline bool AstNode::privateTypeTest<AstFUngetC>(const AstNode* nodep) { return nodep->type() == VNType::FUngetC; }
template<> inline bool AstNode::privateTypeTest<AstFalling>(const AstNode* nodep) { return nodep->type() == VNType::Falling; }
template<> inline bool AstNode::privateTypeTest<AstFell>(const AstNode* nodep) { return nodep->type() == VNType::Fell; }
template<> inline bool AstNode::privateTypeTest<AstFinal>(const AstNode* nodep) { return nodep->type() == VNType::Final; }
template<> inline bool AstNode::privateTypeTest<AstFinish>(const AstNode* nodep) { return nodep->type() == VNType::Finish; }
template<> inline bool AstNode::privateTypeTest<AstFinishFork>(const AstNode* nodep) { return nodep->type() == VNType::FinishFork; }
template<> inline bool AstNode::privateTypeTest<AstFireEvent>(const AstNode* nodep) { return nodep->type() == VNType::FireEvent; }
template<> inline bool AstNode::privateTypeTest<AstFloorD>(const AstNode* nodep) { return nodep->type() == VNType::FloorD; }
template<> inline bool AstNode::privateTypeTest<AstForeach>(const AstNode* nodep) { return nodep->type() == VNType::Foreach; }
template<> inline bool AstNode::privateTypeTest<AstForeachHeader>(const AstNode* nodep) { return nodep->type() == VNType::ForeachHeader; }
template<> inline bool AstNode::privateTypeTest<AstFork>(const AstNode* nodep) { return nodep->type() == VNType::Fork; }
template<> inline bool AstNode::privateTypeTest<AstFunc>(const AstNode* nodep) { return nodep->type() == VNType::Func; }
template<> inline bool AstNode::privateTypeTest<AstFuncRef>(const AstNode* nodep) { return nodep->type() == VNType::FuncRef; }
template<> inline bool AstNode::privateTypeTest<AstFuture>(const AstNode* nodep) { return nodep->type() == VNType::Future; }
template<> inline bool AstNode::privateTypeTest<AstGatePin>(const AstNode* nodep) { return nodep->type() == VNType::GatePin; }
template<> inline bool AstNode::privateTypeTest<AstGenBlock>(const AstNode* nodep) { return nodep->type() == VNType::GenBlock; }
template<> inline bool AstNode::privateTypeTest<AstGenCase>(const AstNode* nodep) { return nodep->type() == VNType::GenCase; }
template<> inline bool AstNode::privateTypeTest<AstGenCaseItem>(const AstNode* nodep) { return nodep->type() == VNType::GenCaseItem; }
template<> inline bool AstNode::privateTypeTest<AstGenFor>(const AstNode* nodep) { return nodep->type() == VNType::GenFor; }
template<> inline bool AstNode::privateTypeTest<AstGenIf>(const AstNode* nodep) { return nodep->type() == VNType::GenIf; }
template<> inline bool AstNode::privateTypeTest<AstGetInitialRandomSeed>(const AstNode* nodep) { return nodep->type() == VNType::GetInitialRandomSeed; }
template<> inline bool AstNode::privateTypeTest<AstGetcN>(const AstNode* nodep) { return nodep->type() == VNType::GetcN; }
template<> inline bool AstNode::privateTypeTest<AstGetcRefN>(const AstNode* nodep) { return nodep->type() == VNType::GetcRefN; }
template<> inline bool AstNode::privateTypeTest<AstGt>(const AstNode* nodep) { return nodep->type() == VNType::Gt; }
template<> inline bool AstNode::privateTypeTest<AstGtD>(const AstNode* nodep) { return nodep->type() == VNType::GtD; }
template<> inline bool AstNode::privateTypeTest<AstGtN>(const AstNode* nodep) { return nodep->type() == VNType::GtN; }
template<> inline bool AstNode::privateTypeTest<AstGtS>(const AstNode* nodep) { return nodep->type() == VNType::GtS; }
template<> inline bool AstNode::privateTypeTest<AstGte>(const AstNode* nodep) { return nodep->type() == VNType::Gte; }
template<> inline bool AstNode::privateTypeTest<AstGteD>(const AstNode* nodep) { return nodep->type() == VNType::GteD; }
template<> inline bool AstNode::privateTypeTest<AstGteN>(const AstNode* nodep) { return nodep->type() == VNType::GteN; }
template<> inline bool AstNode::privateTypeTest<AstGteS>(const AstNode* nodep) { return nodep->type() == VNType::GteS; }
template<> inline bool AstNode::privateTypeTest<AstHypotD>(const AstNode* nodep) { return nodep->type() == VNType::HypotD; }
template<> inline bool AstNode::privateTypeTest<AstISToRD>(const AstNode* nodep) { return nodep->type() == VNType::ISToRD; }
template<> inline bool AstNode::privateTypeTest<AstIToRD>(const AstNode* nodep) { return nodep->type() == VNType::IToRD; }
template<> inline bool AstNode::privateTypeTest<AstIf>(const AstNode* nodep) { return nodep->type() == VNType::If; }
template<> inline bool AstNode::privateTypeTest<AstIface>(const AstNode* nodep) { return nodep->type() == VNType::Iface; }
template<> inline bool AstNode::privateTypeTest<AstIfaceGenericDType>(const AstNode* nodep) { return nodep->type() == VNType::IfaceGenericDType; }
template<> inline bool AstNode::privateTypeTest<AstIfaceRefDType>(const AstNode* nodep) { return nodep->type() == VNType::IfaceRefDType; }
template<> inline bool AstNode::privateTypeTest<AstImplication>(const AstNode* nodep) { return nodep->type() == VNType::Implication; }
template<> inline bool AstNode::privateTypeTest<AstImplicit>(const AstNode* nodep) { return nodep->type() == VNType::Implicit; }
template<> inline bool AstNode::privateTypeTest<AstInferredDisable>(const AstNode* nodep) { return nodep->type() == VNType::InferredDisable; }
template<> inline bool AstNode::privateTypeTest<AstInitArray>(const AstNode* nodep) { return nodep->type() == VNType::InitArray; }
template<> inline bool AstNode::privateTypeTest<AstInitItem>(const AstNode* nodep) { return nodep->type() == VNType::InitItem; }
template<> inline bool AstNode::privateTypeTest<AstInitial>(const AstNode* nodep) { return nodep->type() == VNType::Initial; }
template<> inline bool AstNode::privateTypeTest<AstInitialAutomatic>(const AstNode* nodep) { return nodep->type() == VNType::InitialAutomatic; }
template<> inline bool AstNode::privateTypeTest<AstInitialAutomaticStmt>(const AstNode* nodep) { return nodep->type() == VNType::InitialAutomaticStmt; }
template<> inline bool AstNode::privateTypeTest<AstInitialStatic>(const AstNode* nodep) { return nodep->type() == VNType::InitialStatic; }
template<> inline bool AstNode::privateTypeTest<AstInitialStaticStmt>(const AstNode* nodep) { return nodep->type() == VNType::InitialStaticStmt; }
template<> inline bool AstNode::privateTypeTest<AstInside>(const AstNode* nodep) { return nodep->type() == VNType::Inside; }
template<> inline bool AstNode::privateTypeTest<AstInsideRange>(const AstNode* nodep) { return nodep->type() == VNType::InsideRange; }
template<> inline bool AstNode::privateTypeTest<AstIntfRef>(const AstNode* nodep) { return nodep->type() == VNType::IntfRef; }
template<> inline bool AstNode::privateTypeTest<AstIsUnbounded>(const AstNode* nodep) { return nodep->type() == VNType::IsUnbounded; }
template<> inline bool AstNode::privateTypeTest<AstIsUnknown>(const AstNode* nodep) { return nodep->type() == VNType::IsUnknown; }
template<> inline bool AstNode::privateTypeTest<AstJumpBlock>(const AstNode* nodep) { return nodep->type() == VNType::JumpBlock; }
template<> inline bool AstNode::privateTypeTest<AstJumpGo>(const AstNode* nodep) { return nodep->type() == VNType::JumpGo; }
template<> inline bool AstNode::privateTypeTest<AstLambdaArgRef>(const AstNode* nodep) { return nodep->type() == VNType::LambdaArgRef; }
template<> inline bool AstNode::privateTypeTest<AstLenN>(const AstNode* nodep) { return nodep->type() == VNType::LenN; }
template<> inline bool AstNode::privateTypeTest<AstLet>(const AstNode* nodep) { return nodep->type() == VNType::Let; }
template<> inline bool AstNode::privateTypeTest<AstLibrary>(const AstNode* nodep) { return nodep->type() == VNType::Library; }
template<> inline bool AstNode::privateTypeTest<AstLog10D>(const AstNode* nodep) { return nodep->type() == VNType::Log10D; }
template<> inline bool AstNode::privateTypeTest<AstLogAnd>(const AstNode* nodep) { return nodep->type() == VNType::LogAnd; }
template<> inline bool AstNode::privateTypeTest<AstLogD>(const AstNode* nodep) { return nodep->type() == VNType::LogD; }
template<> inline bool AstNode::privateTypeTest<AstLogEq>(const AstNode* nodep) { return nodep->type() == VNType::LogEq; }
template<> inline bool AstNode::privateTypeTest<AstLogIf>(const AstNode* nodep) { return nodep->type() == VNType::LogIf; }
template<> inline bool AstNode::privateTypeTest<AstLogNot>(const AstNode* nodep) { return nodep->type() == VNType::LogNot; }
template<> inline bool AstNode::privateTypeTest<AstLogOr>(const AstNode* nodep) { return nodep->type() == VNType::LogOr; }
template<> inline bool AstNode::privateTypeTest<AstLoop>(const AstNode* nodep) { return nodep->type() == VNType::Loop; }
template<> inline bool AstNode::privateTypeTest<AstLoopTest>(const AstNode* nodep) { return nodep->type() == VNType::LoopTest; }
template<> inline bool AstNode::privateTypeTest<AstLt>(const AstNode* nodep) { return nodep->type() == VNType::Lt; }
template<> inline bool AstNode::privateTypeTest<AstLtD>(const AstNode* nodep) { return nodep->type() == VNType::LtD; }
template<> inline bool AstNode::privateTypeTest<AstLtN>(const AstNode* nodep) { return nodep->type() == VNType::LtN; }
template<> inline bool AstNode::privateTypeTest<AstLtS>(const AstNode* nodep) { return nodep->type() == VNType::LtS; }
template<> inline bool AstNode::privateTypeTest<AstLte>(const AstNode* nodep) { return nodep->type() == VNType::Lte; }
template<> inline bool AstNode::privateTypeTest<AstLteD>(const AstNode* nodep) { return nodep->type() == VNType::LteD; }
template<> inline bool AstNode::privateTypeTest<AstLteN>(const AstNode* nodep) { return nodep->type() == VNType::LteN; }
template<> inline bool AstNode::privateTypeTest<AstLteS>(const AstNode* nodep) { return nodep->type() == VNType::LteS; }
template<> inline bool AstNode::privateTypeTest<AstMatchMasked>(const AstNode* nodep) { return nodep->type() == VNType::MatchMasked; }
template<> inline bool AstNode::privateTypeTest<AstMatches>(const AstNode* nodep) { return nodep->type() == VNType::Matches; }
template<> inline bool AstNode::privateTypeTest<AstMemberDType>(const AstNode* nodep) { return nodep->type() == VNType::MemberDType; }
template<> inline bool AstNode::privateTypeTest<AstMemberSel>(const AstNode* nodep) { return nodep->type() == VNType::MemberSel; }
template<> inline bool AstNode::privateTypeTest<AstMethodCall>(const AstNode* nodep) { return nodep->type() == VNType::MethodCall; }
template<> inline bool AstNode::privateTypeTest<AstModDiv>(const AstNode* nodep) { return nodep->type() == VNType::ModDiv; }
template<> inline bool AstNode::privateTypeTest<AstModDivS>(const AstNode* nodep) { return nodep->type() == VNType::ModDivS; }
template<> inline bool AstNode::privateTypeTest<AstModport>(const AstNode* nodep) { return nodep->type() == VNType::Modport; }
template<> inline bool AstNode::privateTypeTest<AstModportClockingRef>(const AstNode* nodep) { return nodep->type() == VNType::ModportClockingRef; }
template<> inline bool AstNode::privateTypeTest<AstModportFTaskRef>(const AstNode* nodep) { return nodep->type() == VNType::ModportFTaskRef; }
template<> inline bool AstNode::privateTypeTest<AstModportVarRef>(const AstNode* nodep) { return nodep->type() == VNType::ModportVarRef; }
template<> inline bool AstNode::privateTypeTest<AstModule>(const AstNode* nodep) { return nodep->type() == VNType::Module; }
template<> inline bool AstNode::privateTypeTest<AstMonitorOff>(const AstNode* nodep) { return nodep->type() == VNType::MonitorOff; }
template<> inline bool AstNode::privateTypeTest<AstMostSetBitP1>(const AstNode* nodep) { return nodep->type() == VNType::MostSetBitP1; }
template<> inline bool AstNode::privateTypeTest<AstMul>(const AstNode* nodep) { return nodep->type() == VNType::Mul; }
template<> inline bool AstNode::privateTypeTest<AstMulD>(const AstNode* nodep) { return nodep->type() == VNType::MulD; }
template<> inline bool AstNode::privateTypeTest<AstMulS>(const AstNode* nodep) { return nodep->type() == VNType::MulS; }
template<> inline bool AstNode::privateTypeTest<AstNBACommitQueueDType>(const AstNode* nodep) { return nodep->type() == VNType::NBACommitQueueDType; }
template<> inline bool AstNode::privateTypeTest<AstNToI>(const AstNode* nodep) { return nodep->type() == VNType::NToI; }
template<> inline bool AstNode::privateTypeTest<AstNegate>(const AstNode* nodep) { return nodep->type() == VNType::Negate; }
template<> inline bool AstNode::privateTypeTest<AstNegateD>(const AstNode* nodep) { return nodep->type() == VNType::NegateD; }
template<> inline bool AstNode::privateTypeTest<AstNeq>(const AstNode* nodep) { return nodep->type() == VNType::Neq; }
template<> inline bool AstNode::privateTypeTest<AstNeqCase>(const AstNode* nodep) { return nodep->type() == VNType::NeqCase; }
template<> inline bool AstNode::privateTypeTest<AstNeqD>(const AstNode* nodep) { return nodep->type() == VNType::NeqD; }
template<> inline bool AstNode::privateTypeTest<AstNeqN>(const AstNode* nodep) { return nodep->type() == VNType::NeqN; }
template<> inline bool AstNode::privateTypeTest<AstNeqT>(const AstNode* nodep) { return nodep->type() == VNType::NeqT; }
template<> inline bool AstNode::privateTypeTest<AstNeqWild>(const AstNode* nodep) { return nodep->type() == VNType::NeqWild; }
template<> inline bool AstNode::privateTypeTest<AstNetlist>(const AstNode* nodep) { return nodep->type() == VNType::Netlist; }
template<> inline bool AstNode::privateTypeTest<AstNew>(const AstNode* nodep) { return nodep->type() == VNType::New; }
template<> inline bool AstNode::privateTypeTest<AstNewCopy>(const AstNode* nodep) { return nodep->type() == VNType::NewCopy; }
template<> inline bool AstNode::privateTypeTest<AstNewDynamic>(const AstNode* nodep) { return nodep->type() == VNType::NewDynamic; }
template<> inline bool AstNode::privateTypeTest<AstNode>(const AstNode* nodep) { return true; }
template<> inline bool AstNode::privateTypeTest<AstNodeArrayDType>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeArrayDType) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeArrayDType); }
template<> inline bool AstNode::privateTypeTest<AstNodeAssign>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeAssign) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeAssign); }
template<> inline bool AstNode::privateTypeTest<AstNodeBiCom>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeBiCom) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeBiCom); }
template<> inline bool AstNode::privateTypeTest<AstNodeBiComAsv>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeBiComAsv) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeBiComAsv); }
template<> inline bool AstNode::privateTypeTest<AstNodeBiop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeBiop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeBiop); }
template<> inline bool AstNode::privateTypeTest<AstNodeBlock>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeBlock) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeBlock); }
template<> inline bool AstNode::privateTypeTest<AstNodeCCall>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeCCall) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeCCall); }
template<> inline bool AstNode::privateTypeTest<AstNodeCoverDecl>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeCoverDecl) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeCoverDecl); }
template<> inline bool AstNode::privateTypeTest<AstNodeCoverOrAssert>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeCoverOrAssert) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeCoverOrAssert); }
template<> inline bool AstNode::privateTypeTest<AstNodeDType>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeDType) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeDType); }
template<> inline bool AstNode::privateTypeTest<AstNodeDistBiop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeDistBiop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeDistBiop); }
template<> inline bool AstNode::privateTypeTest<AstNodeDistTriop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeDistTriop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeDistTriop); }
template<> inline bool AstNode::privateTypeTest<AstNodeExpr>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeExpr) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeExpr); }
template<> inline bool AstNode::privateTypeTest<AstNodeFTask>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeFTask) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeFTask); }
template<> inline bool AstNode::privateTypeTest<AstNodeFTaskRef>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeFTaskRef) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeFTaskRef); }
template<> inline bool AstNode::privateTypeTest<AstNodeFile>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeFile) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeFile); }
template<> inline bool AstNode::privateTypeTest<AstNodeForeach>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeForeach) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeForeach); }
template<> inline bool AstNode::privateTypeTest<AstNodeFuncCovItem>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeFuncCovItem) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeFuncCovItem); }
template<> inline bool AstNode::privateTypeTest<AstNodeGen>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeGen) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeGen); }
template<> inline bool AstNode::privateTypeTest<AstNodeIf>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeIf) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeIf); }
template<> inline bool AstNode::privateTypeTest<AstNodeModule>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeModule) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeModule); }
template<> inline bool AstNode::privateTypeTest<AstNodePreSel>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodePreSel) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodePreSel); }
template<> inline bool AstNode::privateTypeTest<AstNodeProcedure>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeProcedure) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeProcedure); }
template<> inline bool AstNode::privateTypeTest<AstNodeQuadop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeQuadop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeQuadop); }
template<> inline bool AstNode::privateTypeTest<AstNodeRange>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeRange) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeRange); }
template<> inline bool AstNode::privateTypeTest<AstNodeReadWriteMem>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeReadWriteMem) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeReadWriteMem); }
template<> inline bool AstNode::privateTypeTest<AstNodeSel>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeSel) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeSel); }
template<> inline bool AstNode::privateTypeTest<AstNodeStmt>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeStmt) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeStmt); }
template<> inline bool AstNode::privateTypeTest<AstNodeStream>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeStream) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeStream); }
template<> inline bool AstNode::privateTypeTest<AstNodeSystemBiopD>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeSystemBiopD) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeSystemBiopD); }
template<> inline bool AstNode::privateTypeTest<AstNodeSystemUniopD>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeSystemUniopD) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeSystemUniopD); }
template<> inline bool AstNode::privateTypeTest<AstNodeTermop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeTermop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeTermop); }
template<> inline bool AstNode::privateTypeTest<AstNodeTriop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeTriop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeTriop); }
template<> inline bool AstNode::privateTypeTest<AstNodeUOrStructDType>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeUOrStructDType) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeUOrStructDType); }
template<> inline bool AstNode::privateTypeTest<AstNodeUniop>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeUniop) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeUniop); }
template<> inline bool AstNode::privateTypeTest<AstNodeVarRef>(const AstNode* nodep) { return static_cast<int>(nodep->type()) >= static_cast<int>(VNType::firstNodeVarRef) && static_cast<int>(nodep->type()) <= static_cast<int>(VNType::lastNodeVarRef); }
template<> inline bool AstNode::privateTypeTest<AstNot>(const AstNode* nodep) { return nodep->type() == VNType::Not; }
template<> inline bool AstNode::privateTypeTest<AstNotFoundModule>(const AstNode* nodep) { return nodep->type() == VNType::NotFoundModule; }
template<> inline bool AstNode::privateTypeTest<AstNullCheck>(const AstNode* nodep) { return nodep->type() == VNType::NullCheck; }
template<> inline bool AstNode::privateTypeTest<AstOneHot>(const AstNode* nodep) { return nodep->type() == VNType::OneHot; }
template<> inline bool AstNode::privateTypeTest<AstOneHot0>(const AstNode* nodep) { return nodep->type() == VNType::OneHot0; }
template<> inline bool AstNode::privateTypeTest<AstOr>(const AstNode* nodep) { return nodep->type() == VNType::Or; }
template<> inline bool AstNode::privateTypeTest<AstPExpr>(const AstNode* nodep) { return nodep->type() == VNType::PExpr; }
template<> inline bool AstNode::privateTypeTest<AstPExprClause>(const AstNode* nodep) { return nodep->type() == VNType::PExprClause; }
template<> inline bool AstNode::privateTypeTest<AstPackArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::PackArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstPackage>(const AstNode* nodep) { return nodep->type() == VNType::Package; }
template<> inline bool AstNode::privateTypeTest<AstPackageExport>(const AstNode* nodep) { return nodep->type() == VNType::PackageExport; }
template<> inline bool AstNode::privateTypeTest<AstPackageExportStarStar>(const AstNode* nodep) { return nodep->type() == VNType::PackageExportStarStar; }
template<> inline bool AstNode::privateTypeTest<AstPackageImport>(const AstNode* nodep) { return nodep->type() == VNType::PackageImport; }
template<> inline bool AstNode::privateTypeTest<AstParamTypeDType>(const AstNode* nodep) { return nodep->type() == VNType::ParamTypeDType; }
template<> inline bool AstNode::privateTypeTest<AstParseHolder>(const AstNode* nodep) { return nodep->type() == VNType::ParseHolder; }
template<> inline bool AstNode::privateTypeTest<AstParseRef>(const AstNode* nodep) { return nodep->type() == VNType::ParseRef; }
template<> inline bool AstNode::privateTypeTest<AstParseTypeDType>(const AstNode* nodep) { return nodep->type() == VNType::ParseTypeDType; }
template<> inline bool AstNode::privateTypeTest<AstPast>(const AstNode* nodep) { return nodep->type() == VNType::Past; }
template<> inline bool AstNode::privateTypeTest<AstPatMember>(const AstNode* nodep) { return nodep->type() == VNType::PatMember; }
template<> inline bool AstNode::privateTypeTest<AstPattern>(const AstNode* nodep) { return nodep->type() == VNType::Pattern; }
template<> inline bool AstNode::privateTypeTest<AstPatternStar>(const AstNode* nodep) { return nodep->type() == VNType::PatternStar; }
template<> inline bool AstNode::privateTypeTest<AstPatternVar>(const AstNode* nodep) { return nodep->type() == VNType::PatternVar; }
template<> inline bool AstNode::privateTypeTest<AstPin>(const AstNode* nodep) { return nodep->type() == VNType::Pin; }
template<> inline bool AstNode::privateTypeTest<AstPort>(const AstNode* nodep) { return nodep->type() == VNType::Port; }
template<> inline bool AstNode::privateTypeTest<AstPostDec>(const AstNode* nodep) { return nodep->type() == VNType::PostDec; }
template<> inline bool AstNode::privateTypeTest<AstPostInc>(const AstNode* nodep) { return nodep->type() == VNType::PostInc; }
template<> inline bool AstNode::privateTypeTest<AstPow>(const AstNode* nodep) { return nodep->type() == VNType::Pow; }
template<> inline bool AstNode::privateTypeTest<AstPowD>(const AstNode* nodep) { return nodep->type() == VNType::PowD; }
template<> inline bool AstNode::privateTypeTest<AstPowSS>(const AstNode* nodep) { return nodep->type() == VNType::PowSS; }
template<> inline bool AstNode::privateTypeTest<AstPowSU>(const AstNode* nodep) { return nodep->type() == VNType::PowSU; }
template<> inline bool AstNode::privateTypeTest<AstPowUS>(const AstNode* nodep) { return nodep->type() == VNType::PowUS; }
template<> inline bool AstNode::privateTypeTest<AstPragma>(const AstNode* nodep) { return nodep->type() == VNType::Pragma; }
template<> inline bool AstNode::privateTypeTest<AstPreDec>(const AstNode* nodep) { return nodep->type() == VNType::PreDec; }
template<> inline bool AstNode::privateTypeTest<AstPreInc>(const AstNode* nodep) { return nodep->type() == VNType::PreInc; }
template<> inline bool AstNode::privateTypeTest<AstPrimitive>(const AstNode* nodep) { return nodep->type() == VNType::Primitive; }
template<> inline bool AstNode::privateTypeTest<AstPrintTimeScale>(const AstNode* nodep) { return nodep->type() == VNType::PrintTimeScale; }
template<> inline bool AstNode::privateTypeTest<AstPropAlways>(const AstNode* nodep) { return nodep->type() == VNType::PropAlways; }
template<> inline bool AstNode::privateTypeTest<AstPropSpec>(const AstNode* nodep) { return nodep->type() == VNType::PropSpec; }
template<> inline bool AstNode::privateTypeTest<AstProperty>(const AstNode* nodep) { return nodep->type() == VNType::Property; }
template<> inline bool AstNode::privateTypeTest<AstPull>(const AstNode* nodep) { return nodep->type() == VNType::Pull; }
template<> inline bool AstNode::privateTypeTest<AstPutcN>(const AstNode* nodep) { return nodep->type() == VNType::PutcN; }
template<> inline bool AstNode::privateTypeTest<AstQueueDType>(const AstNode* nodep) { return nodep->type() == VNType::QueueDType; }
template<> inline bool AstNode::privateTypeTest<AstRSBreak>(const AstNode* nodep) { return nodep->type() == VNType::RSBreak; }
template<> inline bool AstNode::privateTypeTest<AstRSProd>(const AstNode* nodep) { return nodep->type() == VNType::RSProd; }
template<> inline bool AstNode::privateTypeTest<AstRSProdItem>(const AstNode* nodep) { return nodep->type() == VNType::RSProdItem; }
template<> inline bool AstNode::privateTypeTest<AstRSProdList>(const AstNode* nodep) { return nodep->type() == VNType::RSProdList; }
template<> inline bool AstNode::privateTypeTest<AstRSReturn>(const AstNode* nodep) { return nodep->type() == VNType::RSReturn; }
template<> inline bool AstNode::privateTypeTest<AstRSRule>(const AstNode* nodep) { return nodep->type() == VNType::RSRule; }
template<> inline bool AstNode::privateTypeTest<AstRToIRoundS>(const AstNode* nodep) { return nodep->type() == VNType::RToIRoundS; }
template<> inline bool AstNode::privateTypeTest<AstRToIS>(const AstNode* nodep) { return nodep->type() == VNType::RToIS; }
template<> inline bool AstNode::privateTypeTest<AstRand>(const AstNode* nodep) { return nodep->type() == VNType::Rand; }
template<> inline bool AstNode::privateTypeTest<AstRandCase>(const AstNode* nodep) { return nodep->type() == VNType::RandCase; }
template<> inline bool AstNode::privateTypeTest<AstRandRNG>(const AstNode* nodep) { return nodep->type() == VNType::RandRNG; }
template<> inline bool AstNode::privateTypeTest<AstRandSequence>(const AstNode* nodep) { return nodep->type() == VNType::RandSequence; }
template<> inline bool AstNode::privateTypeTest<AstRange>(const AstNode* nodep) { return nodep->type() == VNType::Range; }
template<> inline bool AstNode::privateTypeTest<AstReadMem>(const AstNode* nodep) { return nodep->type() == VNType::ReadMem; }
template<> inline bool AstNode::privateTypeTest<AstRealToBits>(const AstNode* nodep) { return nodep->type() == VNType::RealToBits; }
template<> inline bool AstNode::privateTypeTest<AstRedAnd>(const AstNode* nodep) { return nodep->type() == VNType::RedAnd; }
template<> inline bool AstNode::privateTypeTest<AstRedOr>(const AstNode* nodep) { return nodep->type() == VNType::RedOr; }
template<> inline bool AstNode::privateTypeTest<AstRedXor>(const AstNode* nodep) { return nodep->type() == VNType::RedXor; }
template<> inline bool AstNode::privateTypeTest<AstRefDType>(const AstNode* nodep) { return nodep->type() == VNType::RefDType; }
template<> inline bool AstNode::privateTypeTest<AstRelease>(const AstNode* nodep) { return nodep->type() == VNType::Release; }
template<> inline bool AstNode::privateTypeTest<AstRepeat>(const AstNode* nodep) { return nodep->type() == VNType::Repeat; }
template<> inline bool AstNode::privateTypeTest<AstReplicate>(const AstNode* nodep) { return nodep->type() == VNType::Replicate; }
template<> inline bool AstNode::privateTypeTest<AstReplicateN>(const AstNode* nodep) { return nodep->type() == VNType::ReplicateN; }
template<> inline bool AstNode::privateTypeTest<AstRequireDType>(const AstNode* nodep) { return nodep->type() == VNType::RequireDType; }
template<> inline bool AstNode::privateTypeTest<AstResizeLValue>(const AstNode* nodep) { return nodep->type() == VNType::ResizeLValue; }
template<> inline bool AstNode::privateTypeTest<AstRestrict>(const AstNode* nodep) { return nodep->type() == VNType::Restrict; }
template<> inline bool AstNode::privateTypeTest<AstReturn>(const AstNode* nodep) { return nodep->type() == VNType::Return; }
template<> inline bool AstNode::privateTypeTest<AstRising>(const AstNode* nodep) { return nodep->type() == VNType::Rising; }
template<> inline bool AstNode::privateTypeTest<AstRose>(const AstNode* nodep) { return nodep->type() == VNType::Rose; }
template<> inline bool AstNode::privateTypeTest<AstSAnd>(const AstNode* nodep) { return nodep->type() == VNType::SAnd; }
template<> inline bool AstNode::privateTypeTest<AstSClocked>(const AstNode* nodep) { return nodep->type() == VNType::SClocked; }
template<> inline bool AstNode::privateTypeTest<AstSConsRep>(const AstNode* nodep) { return nodep->type() == VNType::SConsRep; }
template<> inline bool AstNode::privateTypeTest<AstSEventually>(const AstNode* nodep) { return nodep->type() == VNType::SEventually; }
template<> inline bool AstNode::privateTypeTest<AstSExpr>(const AstNode* nodep) { return nodep->type() == VNType::SExpr; }
template<> inline bool AstNode::privateTypeTest<AstSFormat>(const AstNode* nodep) { return nodep->type() == VNType::SFormat; }
template<> inline bool AstNode::privateTypeTest<AstSFormatArg>(const AstNode* nodep) { return nodep->type() == VNType::SFormatArg; }
template<> inline bool AstNode::privateTypeTest<AstSFormatF>(const AstNode* nodep) { return nodep->type() == VNType::SFormatF; }
template<> inline bool AstNode::privateTypeTest<AstSGotoRep>(const AstNode* nodep) { return nodep->type() == VNType::SGotoRep; }
template<> inline bool AstNode::privateTypeTest<AstSIntersect>(const AstNode* nodep) { return nodep->type() == VNType::SIntersect; }
template<> inline bool AstNode::privateTypeTest<AstSNonConsRep>(const AstNode* nodep) { return nodep->type() == VNType::SNonConsRep; }
template<> inline bool AstNode::privateTypeTest<AstSOr>(const AstNode* nodep) { return nodep->type() == VNType::SOr; }
template<> inline bool AstNode::privateTypeTest<AstSScanF>(const AstNode* nodep) { return nodep->type() == VNType::SScanF; }
template<> inline bool AstNode::privateTypeTest<AstSThroughout>(const AstNode* nodep) { return nodep->type() == VNType::SThroughout; }
template<> inline bool AstNode::privateTypeTest<AstSWithin>(const AstNode* nodep) { return nodep->type() == VNType::SWithin; }
template<> inline bool AstNode::privateTypeTest<AstSampleQueueDType>(const AstNode* nodep) { return nodep->type() == VNType::SampleQueueDType; }
template<> inline bool AstNode::privateTypeTest<AstSampled>(const AstNode* nodep) { return nodep->type() == VNType::Sampled; }
template<> inline bool AstNode::privateTypeTest<AstScope>(const AstNode* nodep) { return nodep->type() == VNType::Scope; }
template<> inline bool AstNode::privateTypeTest<AstScopeName>(const AstNode* nodep) { return nodep->type() == VNType::ScopeName; }
template<> inline bool AstNode::privateTypeTest<AstSel>(const AstNode* nodep) { return nodep->type() == VNType::Sel; }
template<> inline bool AstNode::privateTypeTest<AstSelBit>(const AstNode* nodep) { return nodep->type() == VNType::SelBit; }
template<> inline bool AstNode::privateTypeTest<AstSelExtract>(const AstNode* nodep) { return nodep->type() == VNType::SelExtract; }
template<> inline bool AstNode::privateTypeTest<AstSelMinus>(const AstNode* nodep) { return nodep->type() == VNType::SelMinus; }
template<> inline bool AstNode::privateTypeTest<AstSelPlus>(const AstNode* nodep) { return nodep->type() == VNType::SelPlus; }
template<> inline bool AstNode::privateTypeTest<AstSenItem>(const AstNode* nodep) { return nodep->type() == VNType::SenItem; }
template<> inline bool AstNode::privateTypeTest<AstSenTree>(const AstNode* nodep) { return nodep->type() == VNType::SenTree; }
template<> inline bool AstNode::privateTypeTest<AstSequence>(const AstNode* nodep) { return nodep->type() == VNType::Sequence; }
template<> inline bool AstNode::privateTypeTest<AstSetAssoc>(const AstNode* nodep) { return nodep->type() == VNType::SetAssoc; }
template<> inline bool AstNode::privateTypeTest<AstSetWildcard>(const AstNode* nodep) { return nodep->type() == VNType::SetWildcard; }
template<> inline bool AstNode::privateTypeTest<AstSetuphold>(const AstNode* nodep) { return nodep->type() == VNType::Setuphold; }
template<> inline bool AstNode::privateTypeTest<AstShiftL>(const AstNode* nodep) { return nodep->type() == VNType::ShiftL; }
template<> inline bool AstNode::privateTypeTest<AstShiftLOvr>(const AstNode* nodep) { return nodep->type() == VNType::ShiftLOvr; }
template<> inline bool AstNode::privateTypeTest<AstShiftR>(const AstNode* nodep) { return nodep->type() == VNType::ShiftR; }
template<> inline bool AstNode::privateTypeTest<AstShiftROvr>(const AstNode* nodep) { return nodep->type() == VNType::ShiftROvr; }
template<> inline bool AstNode::privateTypeTest<AstShiftRS>(const AstNode* nodep) { return nodep->type() == VNType::ShiftRS; }
template<> inline bool AstNode::privateTypeTest<AstShiftRSOvr>(const AstNode* nodep) { return nodep->type() == VNType::ShiftRSOvr; }
template<> inline bool AstNode::privateTypeTest<AstSigned>(const AstNode* nodep) { return nodep->type() == VNType::Signed; }
template<> inline bool AstNode::privateTypeTest<AstSinD>(const AstNode* nodep) { return nodep->type() == VNType::SinD; }
template<> inline bool AstNode::privateTypeTest<AstSinhD>(const AstNode* nodep) { return nodep->type() == VNType::SinhD; }
template<> inline bool AstNode::privateTypeTest<AstSliceSel>(const AstNode* nodep) { return nodep->type() == VNType::SliceSel; }
template<> inline bool AstNode::privateTypeTest<AstSplitPlaceholder>(const AstNode* nodep) { return nodep->type() == VNType::SplitPlaceholder; }
template<> inline bool AstNode::privateTypeTest<AstSqrtD>(const AstNode* nodep) { return nodep->type() == VNType::SqrtD; }
template<> inline bool AstNode::privateTypeTest<AstStable>(const AstNode* nodep) { return nodep->type() == VNType::Stable; }
template<> inline bool AstNode::privateTypeTest<AstStackTraceF>(const AstNode* nodep) { return nodep->type() == VNType::StackTraceF; }
template<> inline bool AstNode::privateTypeTest<AstStackTraceT>(const AstNode* nodep) { return nodep->type() == VNType::StackTraceT; }
template<> inline bool AstNode::privateTypeTest<AstSteady>(const AstNode* nodep) { return nodep->type() == VNType::Steady; }
template<> inline bool AstNode::privateTypeTest<AstStmtExpr>(const AstNode* nodep) { return nodep->type() == VNType::StmtExpr; }
template<> inline bool AstNode::privateTypeTest<AstStmtPragma>(const AstNode* nodep) { return nodep->type() == VNType::StmtPragma; }
template<> inline bool AstNode::privateTypeTest<AstStop>(const AstNode* nodep) { return nodep->type() == VNType::Stop; }
template<> inline bool AstNode::privateTypeTest<AstStreamDType>(const AstNode* nodep) { return nodep->type() == VNType::StreamDType; }
template<> inline bool AstNode::privateTypeTest<AstStreamL>(const AstNode* nodep) { return nodep->type() == VNType::StreamL; }
template<> inline bool AstNode::privateTypeTest<AstStreamR>(const AstNode* nodep) { return nodep->type() == VNType::StreamR; }
template<> inline bool AstNode::privateTypeTest<AstStrengthSpec>(const AstNode* nodep) { return nodep->type() == VNType::StrengthSpec; }
template<> inline bool AstNode::privateTypeTest<AstStructDType>(const AstNode* nodep) { return nodep->type() == VNType::StructDType; }
template<> inline bool AstNode::privateTypeTest<AstStructSel>(const AstNode* nodep) { return nodep->type() == VNType::StructSel; }
template<> inline bool AstNode::privateTypeTest<AstSub>(const AstNode* nodep) { return nodep->type() == VNType::Sub; }
template<> inline bool AstNode::privateTypeTest<AstSubD>(const AstNode* nodep) { return nodep->type() == VNType::SubD; }
template<> inline bool AstNode::privateTypeTest<AstSubstrN>(const AstNode* nodep) { return nodep->type() == VNType::SubstrN; }
template<> inline bool AstNode::privateTypeTest<AstSysIgnore>(const AstNode* nodep) { return nodep->type() == VNType::SysIgnore; }
template<> inline bool AstNode::privateTypeTest<AstSystemCSection>(const AstNode* nodep) { return nodep->type() == VNType::SystemCSection; }
template<> inline bool AstNode::privateTypeTest<AstSystemF>(const AstNode* nodep) { return nodep->type() == VNType::SystemF; }
template<> inline bool AstNode::privateTypeTest<AstSystemT>(const AstNode* nodep) { return nodep->type() == VNType::SystemT; }
template<> inline bool AstNode::privateTypeTest<AstTaggedExpr>(const AstNode* nodep) { return nodep->type() == VNType::TaggedExpr; }
template<> inline bool AstNode::privateTypeTest<AstTaggedPattern>(const AstNode* nodep) { return nodep->type() == VNType::TaggedPattern; }
template<> inline bool AstNode::privateTypeTest<AstTanD>(const AstNode* nodep) { return nodep->type() == VNType::TanD; }
template<> inline bool AstNode::privateTypeTest<AstTanhD>(const AstNode* nodep) { return nodep->type() == VNType::TanhD; }
template<> inline bool AstNode::privateTypeTest<AstTask>(const AstNode* nodep) { return nodep->type() == VNType::Task; }
template<> inline bool AstNode::privateTypeTest<AstTaskRef>(const AstNode* nodep) { return nodep->type() == VNType::TaskRef; }
template<> inline bool AstNode::privateTypeTest<AstTestPlusArgs>(const AstNode* nodep) { return nodep->type() == VNType::TestPlusArgs; }
template<> inline bool AstNode::privateTypeTest<AstText>(const AstNode* nodep) { return nodep->type() == VNType::Text; }
template<> inline bool AstNode::privateTypeTest<AstTextBlock>(const AstNode* nodep) { return nodep->type() == VNType::TextBlock; }
template<> inline bool AstNode::privateTypeTest<AstThisRef>(const AstNode* nodep) { return nodep->type() == VNType::ThisRef; }
template<> inline bool AstNode::privateTypeTest<AstTime>(const AstNode* nodep) { return nodep->type() == VNType::Time; }
template<> inline bool AstNode::privateTypeTest<AstTimeD>(const AstNode* nodep) { return nodep->type() == VNType::TimeD; }
template<> inline bool AstNode::privateTypeTest<AstTimeFormat>(const AstNode* nodep) { return nodep->type() == VNType::TimeFormat; }
template<> inline bool AstNode::privateTypeTest<AstTimeImport>(const AstNode* nodep) { return nodep->type() == VNType::TimeImport; }
template<> inline bool AstNode::privateTypeTest<AstTimePrecision>(const AstNode* nodep) { return nodep->type() == VNType::TimePrecision; }
template<> inline bool AstNode::privateTypeTest<AstTimeUnit>(const AstNode* nodep) { return nodep->type() == VNType::TimeUnit; }
template<> inline bool AstNode::privateTypeTest<AstToLowerN>(const AstNode* nodep) { return nodep->type() == VNType::ToLowerN; }
template<> inline bool AstNode::privateTypeTest<AstToStringN>(const AstNode* nodep) { return nodep->type() == VNType::ToStringN; }
template<> inline bool AstNode::privateTypeTest<AstToUpperN>(const AstNode* nodep) { return nodep->type() == VNType::ToUpperN; }
template<> inline bool AstNode::privateTypeTest<AstTopScope>(const AstNode* nodep) { return nodep->type() == VNType::TopScope; }
template<> inline bool AstNode::privateTypeTest<AstTraceDecl>(const AstNode* nodep) { return nodep->type() == VNType::TraceDecl; }
template<> inline bool AstNode::privateTypeTest<AstTraceInc>(const AstNode* nodep) { return nodep->type() == VNType::TraceInc; }
template<> inline bool AstNode::privateTypeTest<AstTracePopPrefix>(const AstNode* nodep) { return nodep->type() == VNType::TracePopPrefix; }
template<> inline bool AstNode::privateTypeTest<AstTracePushPrefix>(const AstNode* nodep) { return nodep->type() == VNType::TracePushPrefix; }
template<> inline bool AstNode::privateTypeTest<AstTypeTable>(const AstNode* nodep) { return nodep->type() == VNType::TypeTable; }
template<> inline bool AstNode::privateTypeTest<AstTypedef>(const AstNode* nodep) { return nodep->type() == VNType::Typedef; }
template<> inline bool AstNode::privateTypeTest<AstTypedefFwd>(const AstNode* nodep) { return nodep->type() == VNType::TypedefFwd; }
template<> inline bool AstNode::privateTypeTest<AstURandomRange>(const AstNode* nodep) { return nodep->type() == VNType::URandomRange; }
template<> inline bool AstNode::privateTypeTest<AstUdpTable>(const AstNode* nodep) { return nodep->type() == VNType::UdpTable; }
template<> inline bool AstNode::privateTypeTest<AstUdpTableLine>(const AstNode* nodep) { return nodep->type() == VNType::UdpTableLine; }
template<> inline bool AstNode::privateTypeTest<AstUdpTableLineVal>(const AstNode* nodep) { return nodep->type() == VNType::UdpTableLineVal; }
template<> inline bool AstNode::privateTypeTest<AstUnbounded>(const AstNode* nodep) { return nodep->type() == VNType::Unbounded; }
template<> inline bool AstNode::privateTypeTest<AstUnionDType>(const AstNode* nodep) { return nodep->type() == VNType::UnionDType; }
template<> inline bool AstNode::privateTypeTest<AstUnlinkedRef>(const AstNode* nodep) { return nodep->type() == VNType::UnlinkedRef; }
template<> inline bool AstNode::privateTypeTest<AstUnpackArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::UnpackArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstUnsigned>(const AstNode* nodep) { return nodep->type() == VNType::Unsigned; }
template<> inline bool AstNode::privateTypeTest<AstUnsizedArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::UnsizedArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstUnsizedRange>(const AstNode* nodep) { return nodep->type() == VNType::UnsizedRange; }
template<> inline bool AstNode::privateTypeTest<AstUntil>(const AstNode* nodep) { return nodep->type() == VNType::Until; }
template<> inline bool AstNode::privateTypeTest<AstVFile>(const AstNode* nodep) { return nodep->type() == VNType::VFile; }
template<> inline bool AstNode::privateTypeTest<AstValuePlusArgs>(const AstNode* nodep) { return nodep->type() == VNType::ValuePlusArgs; }
template<> inline bool AstNode::privateTypeTest<AstVar>(const AstNode* nodep) { return nodep->type() == VNType::Var; }
template<> inline bool AstNode::privateTypeTest<AstVarRef>(const AstNode* nodep) { return nodep->type() == VNType::VarRef; }
template<> inline bool AstNode::privateTypeTest<AstVarScope>(const AstNode* nodep) { return nodep->type() == VNType::VarScope; }
template<> inline bool AstNode::privateTypeTest<AstVarXRef>(const AstNode* nodep) { return nodep->type() == VNType::VarXRef; }
template<> inline bool AstNode::privateTypeTest<AstVoidDType>(const AstNode* nodep) { return nodep->type() == VNType::VoidDType; }
template<> inline bool AstNode::privateTypeTest<AstWait>(const AstNode* nodep) { return nodep->type() == VNType::Wait; }
template<> inline bool AstNode::privateTypeTest<AstWaitFork>(const AstNode* nodep) { return nodep->type() == VNType::WaitFork; }
template<> inline bool AstNode::privateTypeTest<AstWildcardArrayDType>(const AstNode* nodep) { return nodep->type() == VNType::WildcardArrayDType; }
template<> inline bool AstNode::privateTypeTest<AstWildcardRange>(const AstNode* nodep) { return nodep->type() == VNType::WildcardRange; }
template<> inline bool AstNode::privateTypeTest<AstWildcardSel>(const AstNode* nodep) { return nodep->type() == VNType::WildcardSel; }
template<> inline bool AstNode::privateTypeTest<AstWith>(const AstNode* nodep) { return nodep->type() == VNType::With; }
template<> inline bool AstNode::privateTypeTest<AstWithParse>(const AstNode* nodep) { return nodep->type() == VNType::WithParse; }
template<> inline bool AstNode::privateTypeTest<AstWordSel>(const AstNode* nodep) { return nodep->type() == VNType::WordSel; }
template<> inline bool AstNode::privateTypeTest<AstWriteMem>(const AstNode* nodep) { return nodep->type() == VNType::WriteMem; }
template<> inline bool AstNode::privateTypeTest<AstXor>(const AstNode* nodep) { return nodep->type() == VNType::Xor; }
