generated.h

#ifndef Rose_Traits_generated_h
#define Rose_Traits_generated_h
namespace Rose {
namespace Traits {
namespace generated {
// Class: AccessModifier
template <> struct describe_field_t<SgAccessModifier,SgAccessModifier::access_modifier_enum,&SgAccessModifier::p_modifier> {
  using parent = SgAccessModifier;
  using field_type = SgAccessModifier::access_modifier_enum;
  static constexpr size_t position{0};
  static constexpr char const * const name{"modifier"};
  static constexpr char const * const typestr{"SgAccessModifier::access_modifier_enum"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAccessModifier::p_modifier};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAccessModifier, SgAccessModifier::access_modifier_enum SgAccessModifier::*, &SgAccessModifier::p_modifier>;
};
template <> struct describe_node_t<SgAccessModifier> {
  using node = SgAccessModifier;
  using base = SgModifier;
  static constexpr char const * const name{"AccessModifier"};
  static constexpr unsigned long variant{1};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAccessModifier,SgAccessModifier::access_modifier_enum,&SgAccessModifier::p_modifier>>;
};
template <> struct node_from_variant_t<1> { using type = SgAccessModifier; };

// Class: ActualArgumentExpression
template <> struct describe_field_t<SgActualArgumentExpression,SgName,&SgActualArgumentExpression::p_argument_name> {
  using parent = SgActualArgumentExpression;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"argument_name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_argument_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgActualArgumentExpression, SgName SgActualArgumentExpression::*, &SgActualArgumentExpression::p_argument_name>;
};
template <> struct describe_field_t<SgActualArgumentExpression,SgExpression*,&SgActualArgumentExpression::p_expression> {
  using parent = SgActualArgumentExpression;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"expression"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_expression};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgActualArgumentExpression, SgExpression* SgActualArgumentExpression::*, &SgActualArgumentExpression::p_expression>;
};
template <> struct describe_node_t<SgActualArgumentExpression> {
  using node = SgActualArgumentExpression;
  using base = SgExpression;
  static constexpr char const * const name{"ActualArgumentExpression"};
  static constexpr unsigned long variant{2};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgActualArgumentExpression,SgName,&SgActualArgumentExpression::p_argument_name>, describe_field_t<SgActualArgumentExpression,SgExpression*,&SgActualArgumentExpression::p_expression>>;
};
template <> struct node_from_variant_t<2> { using type = SgActualArgumentExpression; };

// Class: AbsOp
template <> struct describe_node_t<SgAbsOp> {
  using node = SgAbsOp;
  using base = SgUnaryOp;
  static constexpr char const * const name{"AbsOp"};
  static constexpr unsigned long variant{3};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<3> { using type = SgAbsOp; };

// Class: AdaAccessType
template <> struct describe_field_t<SgAdaAccessType,SgType*,&SgAdaAccessType::p_base_type> {
  using parent = SgAdaAccessType;
  using field_type = SgType*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"base_type"};
  static constexpr char const * const typestr{"SgType*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaAccessType::p_base_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAccessType, SgType* SgAdaAccessType::*, &SgAdaAccessType::p_base_type>;
};
template <> struct describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_general_access> {
  using parent = SgAdaAccessType;
  using field_type = bool;
  static constexpr size_t position{1};
  static constexpr char const * const name{"is_general_access"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaAccessType::p_is_general_access};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAccessType, bool SgAdaAccessType::*, &SgAdaAccessType::p_is_general_access>;
};
template <> struct describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_anonymous> {
  using parent = SgAdaAccessType;
  using field_type = bool;
  static constexpr size_t position{2};
  static constexpr char const * const name{"is_anonymous"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaAccessType::p_is_anonymous};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAccessType, bool SgAdaAccessType::*, &SgAdaAccessType::p_is_anonymous>;
};
template <> struct describe_node_t<SgAdaAccessType> {
  using node = SgAdaAccessType;
  using base = SgType;
  static constexpr char const * const name{"AdaAccessType"};
  static constexpr unsigned long variant{4};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaAccessType,SgType*,&SgAdaAccessType::p_base_type>, describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_general_access>, describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_anonymous>>;
};
template <> struct node_from_variant_t<4> { using type = SgAdaAccessType; };

// Class: AdaAcceptStmt
template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterScope*,&SgAdaAcceptStmt::p_parameterScope> {
  using parent = SgAdaAcceptStmt;
  using field_type = SgFunctionParameterScope*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"parameterScope"};
  static constexpr char const * const typestr{"SgFunctionParameterScope*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterScope};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterScope* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterScope>;
};
template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterList*,&SgAdaAcceptStmt::p_parameterList> {
  using parent = SgAdaAcceptStmt;
  using field_type = SgFunctionParameterList*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"parameterList"};
  static constexpr char const * const typestr{"SgFunctionParameterList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterList};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterList* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterList>;
};
template <> struct describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_entry> {
  using parent = SgAdaAcceptStmt;
  using field_type = SgExpression*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"entry"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_entry};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAcceptStmt, SgExpression* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_entry>;
};
template <> struct describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_index> {
  using parent = SgAdaAcceptStmt;
  using field_type = SgExpression*;
  static constexpr size_t position{3};
  static constexpr char const * const name{"index"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_index};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAcceptStmt, SgExpression* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_index>;
};
template <> struct describe_field_t<SgAdaAcceptStmt,SgStatement*,&SgAdaAcceptStmt::p_body> {
  using parent = SgAdaAcceptStmt;
  using field_type = SgStatement*;
  static constexpr size_t position{4};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgStatement*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaAcceptStmt, SgStatement* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_body>;
};
template <> struct describe_node_t<SgAdaAcceptStmt> {
  using node = SgAdaAcceptStmt;
  using base = SgScopeStatement;
  static constexpr char const * const name{"AdaAcceptStmt"};
  static constexpr unsigned long variant{5};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaAcceptStmt,SgFunctionParameterScope*,&SgAdaAcceptStmt::p_parameterScope>, describe_field_t<SgAdaAcceptStmt,SgFunctionParameterList*,&SgAdaAcceptStmt::p_parameterList>, describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_entry>, describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_index>, describe_field_t<SgAdaAcceptStmt,SgStatement*,&SgAdaAcceptStmt::p_body>>;
};
template <> struct node_from_variant_t<5> { using type = SgAdaAcceptStmt; };

// Class: AdaDelayStmt
template <> struct describe_field_t<SgAdaDelayStmt,SgExpression*,&SgAdaDelayStmt::p_time> {
  using parent = SgAdaDelayStmt;
  using field_type = SgExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"time"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaDelayStmt::p_time};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaDelayStmt, SgExpression* SgAdaDelayStmt::*, &SgAdaDelayStmt::p_time>;
};
template <> struct describe_field_t<SgAdaDelayStmt,bool,&SgAdaDelayStmt::p_isRelative> {
  using parent = SgAdaDelayStmt;
  using field_type = bool;
  static constexpr size_t position{1};
  static constexpr char const * const name{"isRelative"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaDelayStmt::p_isRelative};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaDelayStmt, bool SgAdaDelayStmt::*, &SgAdaDelayStmt::p_isRelative>;
};
template <> struct describe_node_t<SgAdaDelayStmt> {
  using node = SgAdaDelayStmt;
  using base = SgStatement;
  static constexpr char const * const name{"AdaDelayStmt"};
  static constexpr unsigned long variant{6};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaDelayStmt,SgExpression*,&SgAdaDelayStmt::p_time>, describe_field_t<SgAdaDelayStmt,bool,&SgAdaDelayStmt::p_isRelative>>;
};
template <> struct node_from_variant_t<6> { using type = SgAdaDelayStmt; };

// Class: AdaEntryDecl
template <> struct describe_field_t<SgAdaEntryDecl,SgInitializedName*,&SgAdaEntryDecl::p_entryIndex> {
  using parent = SgAdaEntryDecl;
  using field_type = SgInitializedName*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"entryIndex"};
  static constexpr char const * const typestr{"SgInitializedName*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaEntryDecl::p_entryIndex};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaEntryDecl, SgInitializedName* SgAdaEntryDecl::*, &SgAdaEntryDecl::p_entryIndex>;
};
template <> struct describe_field_t<SgAdaEntryDecl,SgExpression*,&SgAdaEntryDecl::p_entryBarrier> {
  using parent = SgAdaEntryDecl;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"entryBarrier"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaEntryDecl::p_entryBarrier};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaEntryDecl, SgExpression* SgAdaEntryDecl::*, &SgAdaEntryDecl::p_entryBarrier>;
};
template <> struct describe_node_t<SgAdaEntryDecl> {
  using node = SgAdaEntryDecl;
  using base = SgFunctionDeclaration;
  static constexpr char const * const name{"AdaEntryDecl"};
  static constexpr unsigned long variant{7};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaEntryDecl,SgInitializedName*,&SgAdaEntryDecl::p_entryIndex>, describe_field_t<SgAdaEntryDecl,SgExpression*,&SgAdaEntryDecl::p_entryBarrier>>;
};
template <> struct node_from_variant_t<7> { using type = SgAdaEntryDecl; };

// Class: AdaExitStmt
template <> struct describe_field_t<SgAdaExitStmt,SgStatement*,&SgAdaExitStmt::p_loop> {
  using parent = SgAdaExitStmt;
  using field_type = SgStatement*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"loop"};
  static constexpr char const * const typestr{"SgStatement*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaExitStmt::p_loop};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaExitStmt, SgStatement* SgAdaExitStmt::*, &SgAdaExitStmt::p_loop>;
};
template <> struct describe_field_t<SgAdaExitStmt,SgExpression*,&SgAdaExitStmt::p_condition> {
  using parent = SgAdaExitStmt;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"condition"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaExitStmt::p_condition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaExitStmt, SgExpression* SgAdaExitStmt::*, &SgAdaExitStmt::p_condition>;
};
template <> struct describe_field_t<SgAdaExitStmt,bool,&SgAdaExitStmt::p_explicitLoopName> {
  using parent = SgAdaExitStmt;
  using field_type = bool;
  static constexpr size_t position{2};
  static constexpr char const * const name{"explicitLoopName"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaExitStmt::p_explicitLoopName};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaExitStmt, bool SgAdaExitStmt::*, &SgAdaExitStmt::p_explicitLoopName>;
};
template <> struct describe_node_t<SgAdaExitStmt> {
  using node = SgAdaExitStmt;
  using base = SgStatement;
  static constexpr char const * const name{"AdaExitStmt"};
  static constexpr unsigned long variant{8};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaExitStmt,SgStatement*,&SgAdaExitStmt::p_loop>, describe_field_t<SgAdaExitStmt,SgExpression*,&SgAdaExitStmt::p_condition>, describe_field_t<SgAdaExitStmt,bool,&SgAdaExitStmt::p_explicitLoopName>>;
};
template <> struct node_from_variant_t<8> { using type = SgAdaExitStmt; };

// Class: AdaDiscreteType
template <> struct describe_node_t<SgAdaDiscreteType> {
  using node = SgAdaDiscreteType;
  using base = SgType;
  static constexpr char const * const name{"AdaDiscreteType"};
  static constexpr unsigned long variant{9};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<9> { using type = SgAdaDiscreteType; };

// Class: AdaFloatVal
template <> struct describe_field_t<SgAdaFloatVal,std::string,&SgAdaFloatVal::p_valueString> {
  using parent = SgAdaFloatVal;
  using field_type = std::string;
  static constexpr size_t position{0};
  static constexpr char const * const name{"valueString"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaFloatVal::p_valueString};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaFloatVal, std::string SgAdaFloatVal::*, &SgAdaFloatVal::p_valueString>;
};
template <> struct describe_node_t<SgAdaFloatVal> {
  using node = SgAdaFloatVal;
  using base = SgValueExp;
  static constexpr char const * const name{"AdaFloatVal"};
  static constexpr unsigned long variant{10};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaFloatVal,std::string,&SgAdaFloatVal::p_valueString>>;
};
template <> struct node_from_variant_t<10> { using type = SgAdaFloatVal; };

// Class: AdaLoopStmt
template <> struct describe_field_t<SgAdaLoopStmt,SgBasicBlock*,&SgAdaLoopStmt::p_body> {
  using parent = SgAdaLoopStmt;
  using field_type = SgBasicBlock*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgBasicBlock*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaLoopStmt::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaLoopStmt, SgBasicBlock* SgAdaLoopStmt::*, &SgAdaLoopStmt::p_body>;
};
template <> struct describe_field_t<SgAdaLoopStmt,std::string,&SgAdaLoopStmt::p_string_label> {
  using parent = SgAdaLoopStmt;
  using field_type = std::string;
  static constexpr size_t position{1};
  static constexpr char const * const name{"string_label"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaLoopStmt::p_string_label};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaLoopStmt, std::string SgAdaLoopStmt::*, &SgAdaLoopStmt::p_string_label>;
};
template <> struct describe_node_t<SgAdaLoopStmt> {
  using node = SgAdaLoopStmt;
  using base = SgStatement;
  static constexpr char const * const name{"AdaLoopStmt"};
  static constexpr unsigned long variant{11};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaLoopStmt,SgBasicBlock*,&SgAdaLoopStmt::p_body>, describe_field_t<SgAdaLoopStmt,std::string,&SgAdaLoopStmt::p_string_label>>;
};
template <> struct node_from_variant_t<11> { using type = SgAdaLoopStmt; };

// Class: AdaPackageBody
template <> struct describe_field_t<SgAdaPackageBody,SgAdaPackageSpec*,&SgAdaPackageBody::p_spec> {
  using parent = SgAdaPackageBody;
  using field_type = SgAdaPackageSpec*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"spec"};
  static constexpr char const * const typestr{"SgAdaPackageSpec*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageBody::p_spec};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageBody, SgAdaPackageSpec* SgAdaPackageBody::*, &SgAdaPackageBody::p_spec>;
};
template <> struct describe_field_t<SgAdaPackageBody,SgStatementPtrList,&SgAdaPackageBody::p_statements> {
  using parent = SgAdaPackageBody;
  using field_type = SgStatementPtrList;
  static constexpr size_t position{1};
  static constexpr char const * const name{"statements"};
  static constexpr char const * const typestr{"SgStatementPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaPackageBody::p_statements};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageBody, SgStatementPtrList SgAdaPackageBody::*, &SgAdaPackageBody::p_statements>;
};
template <> struct describe_node_t<SgAdaPackageBody> {
  using node = SgAdaPackageBody;
  using base = SgScopeStatement;
  static constexpr char const * const name{"AdaPackageBody"};
  static constexpr unsigned long variant{12};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaPackageBody,SgAdaPackageSpec*,&SgAdaPackageBody::p_spec>, describe_field_t<SgAdaPackageBody,SgStatementPtrList,&SgAdaPackageBody::p_statements>>;
};
template <> struct node_from_variant_t<12> { using type = SgAdaPackageBody; };

// Class: AdaPackageBodyDecl
template <> struct describe_field_t<SgAdaPackageBodyDecl,SgName,&SgAdaPackageBodyDecl::p_name> {
  using parent = SgAdaPackageBodyDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageBodyDecl, SgName SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_name>;
};
template <> struct describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageBody*,&SgAdaPackageBodyDecl::p_definition> {
  using parent = SgAdaPackageBodyDecl;
  using field_type = SgAdaPackageBody*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"definition"};
  static constexpr char const * const typestr{"SgAdaPackageBody*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_definition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageBodyDecl, SgAdaPackageBody* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_definition>;
};
template <> struct describe_field_t<SgAdaPackageBodyDecl,SgScopeStatement*,&SgAdaPackageBodyDecl::p_scope> {
  using parent = SgAdaPackageBodyDecl;
  using field_type = SgScopeStatement*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"scope"};
  static constexpr char const * const typestr{"SgScopeStatement*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_scope};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageBodyDecl, SgScopeStatement* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_scope>;
};
template <> struct describe_node_t<SgAdaPackageBodyDecl> {
  using node = SgAdaPackageBodyDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaPackageBodyDecl"};
  static constexpr unsigned long variant{13};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaPackageBodyDecl,SgName,&SgAdaPackageBodyDecl::p_name>, describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageBody*,&SgAdaPackageBodyDecl::p_definition>, describe_field_t<SgAdaPackageBodyDecl,SgScopeStatement*,&SgAdaPackageBodyDecl::p_scope>>;
};
template <> struct node_from_variant_t<13> { using type = SgAdaPackageBodyDecl; };

// Class: AdaPackageSpec
template <> struct describe_field_t<SgAdaPackageSpec,SgAdaPackageBody*,&SgAdaPackageSpec::p_body> {
  using parent = SgAdaPackageSpec;
  using field_type = SgAdaPackageBody*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAdaPackageBody*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpec, SgAdaPackageBody* SgAdaPackageSpec::*, &SgAdaPackageSpec::p_body>;
};
template <> struct describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate> {
  using parent = SgAdaPackageSpec;
  using field_type = bool;
  static constexpr size_t position{1};
  static constexpr char const * const name{"hasPrivate"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_hasPrivate};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpec, bool SgAdaPackageSpec::*, &SgAdaPackageSpec::p_hasPrivate>;
};
template <> struct describe_field_t<SgAdaPackageSpec,SgDeclarationStatementPtrList,&SgAdaPackageSpec::p_declarations> {
  using parent = SgAdaPackageSpec;
  using field_type = SgDeclarationStatementPtrList;
  static constexpr size_t position{2};
  static constexpr char const * const name{"declarations"};
  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_declarations};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpec, SgDeclarationStatementPtrList SgAdaPackageSpec::*, &SgAdaPackageSpec::p_declarations>;
};
template <> struct describe_node_t<SgAdaPackageSpec> {
  using node = SgAdaPackageSpec;
  using base = SgScopeStatement;
  static constexpr char const * const name{"AdaPackageSpec"};
  static constexpr unsigned long variant{14};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaPackageSpec,SgAdaPackageBody*,&SgAdaPackageSpec::p_body>, describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate>, describe_field_t<SgAdaPackageSpec,SgDeclarationStatementPtrList,&SgAdaPackageSpec::p_declarations>>;
};
template <> struct node_from_variant_t<14> { using type = SgAdaPackageSpec; };

// Class: AdaPackageSpecDecl
template <> struct describe_field_t<SgAdaPackageSpecDecl,SgName,&SgAdaPackageSpecDecl::p_name> {
  using parent = SgAdaPackageSpecDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpecDecl, SgName SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_name>;
};
template <> struct describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageSpec*,&SgAdaPackageSpecDecl::p_definition> {
  using parent = SgAdaPackageSpecDecl;
  using field_type = SgAdaPackageSpec*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"definition"};
  static constexpr char const * const typestr{"SgAdaPackageSpec*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_definition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpecDecl, SgAdaPackageSpec* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_definition>;
};
template <> struct describe_field_t<SgAdaPackageSpecDecl,SgScopeStatement*,&SgAdaPackageSpecDecl::p_scope> {
  using parent = SgAdaPackageSpecDecl;
  using field_type = SgScopeStatement*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"scope"};
  static constexpr char const * const typestr{"SgScopeStatement*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_scope};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSpecDecl, SgScopeStatement* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_scope>;
};
template <> struct describe_node_t<SgAdaPackageSpecDecl> {
  using node = SgAdaPackageSpecDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaPackageSpecDecl"};
  static constexpr unsigned long variant{15};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaPackageSpecDecl,SgName,&SgAdaPackageSpecDecl::p_name>, describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageSpec*,&SgAdaPackageSpecDecl::p_definition>, describe_field_t<SgAdaPackageSpecDecl,SgScopeStatement*,&SgAdaPackageSpecDecl::p_scope>>;
};
template <> struct node_from_variant_t<15> { using type = SgAdaPackageSpecDecl; };

// Class: AdaPackageSymbol
template <> struct describe_field_t<SgAdaPackageSymbol,SgDeclarationStatement*,&SgAdaPackageSymbol::p_declaration> {
  using parent = SgAdaPackageSymbol;
  using field_type = SgDeclarationStatement*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"declaration"};
  static constexpr char const * const typestr{"SgDeclarationStatement*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaPackageSymbol::p_declaration};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaPackageSymbol, SgDeclarationStatement* SgAdaPackageSymbol::*, &SgAdaPackageSymbol::p_declaration>;
};
template <> struct describe_node_t<SgAdaPackageSymbol> {
  using node = SgAdaPackageSymbol;
  using base = SgSymbol;
  static constexpr char const * const name{"AdaPackageSymbol"};
  static constexpr unsigned long variant{16};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaPackageSymbol,SgDeclarationStatement*,&SgAdaPackageSymbol::p_declaration>>;
};
template <> struct node_from_variant_t<16> { using type = SgAdaPackageSymbol; };

// Class: AdaRangeConstraint
template <> struct describe_field_t<SgAdaRangeConstraint,SgExpression*,&SgAdaRangeConstraint::p_range> {
  using parent = SgAdaRangeConstraint;
  using field_type = SgExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"range"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaRangeConstraint::p_range};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaRangeConstraint, SgExpression* SgAdaRangeConstraint::*, &SgAdaRangeConstraint::p_range>;
};
template <> struct describe_node_t<SgAdaRangeConstraint> {
  using node = SgAdaRangeConstraint;
  using base = SgAdaTypeConstraint;
  static constexpr char const * const name{"AdaRangeConstraint"};
  static constexpr unsigned long variant{17};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaRangeConstraint,SgExpression*,&SgAdaRangeConstraint::p_range>>;
};
template <> struct node_from_variant_t<17> { using type = SgAdaRangeConstraint; };

// Class: AdaRenamingDecl
template <> struct describe_field_t<SgAdaRenamingDecl,SgName,&SgAdaRenamingDecl::p_name> {
  using parent = SgAdaRenamingDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaRenamingDecl, SgName SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_name>;
};
template <> struct describe_field_t<SgAdaRenamingDecl,SgExpression*,&SgAdaRenamingDecl::p_renamed> {
  using parent = SgAdaRenamingDecl;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"renamed"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_renamed};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaRenamingDecl, SgExpression* SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_renamed>;
};
template <> struct describe_field_t<SgAdaRenamingDecl,SgType*,&SgAdaRenamingDecl::p_type> {
  using parent = SgAdaRenamingDecl;
  using field_type = SgType*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"type"};
  static constexpr char const * const typestr{"SgType*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaRenamingDecl, SgType* SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_type>;
};
template <> struct describe_node_t<SgAdaRenamingDecl> {
  using node = SgAdaRenamingDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaRenamingDecl"};
  static constexpr unsigned long variant{18};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaRenamingDecl,SgName,&SgAdaRenamingDecl::p_name>, describe_field_t<SgAdaRenamingDecl,SgExpression*,&SgAdaRenamingDecl::p_renamed>, describe_field_t<SgAdaRenamingDecl,SgType*,&SgAdaRenamingDecl::p_type>>;
};
template <> struct node_from_variant_t<18> { using type = SgAdaRenamingDecl; };

// Class: AdaSubtype
template <> struct describe_field_t<SgAdaSubtype,SgType*,&SgAdaSubtype::p_base_type> {
  using parent = SgAdaSubtype;
  using field_type = SgType*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"base_type"};
  static constexpr char const * const typestr{"SgType*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaSubtype::p_base_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaSubtype, SgType* SgAdaSubtype::*, &SgAdaSubtype::p_base_type>;
};
template <> struct describe_field_t<SgAdaSubtype,SgAdaTypeConstraint*,&SgAdaSubtype::p_constraint> {
  using parent = SgAdaSubtype;
  using field_type = SgAdaTypeConstraint*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"constraint"};
  static constexpr char const * const typestr{"SgAdaTypeConstraint*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaSubtype::p_constraint};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaSubtype, SgAdaTypeConstraint* SgAdaSubtype::*, &SgAdaSubtype::p_constraint>;
};
template <> struct describe_field_t<SgAdaSubtype,bool,&SgAdaSubtype::p_fromRootType> {
  using parent = SgAdaSubtype;
  using field_type = bool;
  static constexpr size_t position{2};
  static constexpr char const * const name{"fromRootType"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaSubtype::p_fromRootType};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaSubtype, bool SgAdaSubtype::*, &SgAdaSubtype::p_fromRootType>;
};
template <> struct describe_node_t<SgAdaSubtype> {
  using node = SgAdaSubtype;
  using base = SgType;
  static constexpr char const * const name{"AdaSubtype"};
  static constexpr unsigned long variant{19};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaSubtype,SgType*,&SgAdaSubtype::p_base_type>, describe_field_t<SgAdaSubtype,SgAdaTypeConstraint*,&SgAdaSubtype::p_constraint>, describe_field_t<SgAdaSubtype,bool,&SgAdaSubtype::p_fromRootType>>;
};
template <> struct node_from_variant_t<19> { using type = SgAdaSubtype; };

// Class: AdaTaskBody
template <> struct describe_field_t<SgAdaTaskBody,SgAdaTaskSpec*,&SgAdaTaskBody::p_spec> {
  using parent = SgAdaTaskBody;
  using field_type = SgAdaTaskSpec*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"spec"};
  static constexpr char const * const typestr{"SgAdaTaskSpec*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskBody::p_spec};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskBody, SgAdaTaskSpec* SgAdaTaskBody::*, &SgAdaTaskBody::p_spec>;
};
template <> struct describe_field_t<SgAdaTaskBody,SgStatementPtrList,&SgAdaTaskBody::p_statements> {
  using parent = SgAdaTaskBody;
  using field_type = SgStatementPtrList;
  static constexpr size_t position{1};
  static constexpr char const * const name{"statements"};
  static constexpr char const * const typestr{"SgStatementPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskBody::p_statements};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskBody, SgStatementPtrList SgAdaTaskBody::*, &SgAdaTaskBody::p_statements>;
};
template <> struct describe_node_t<SgAdaTaskBody> {
  using node = SgAdaTaskBody;
  using base = SgScopeStatement;
  static constexpr char const * const name{"AdaTaskBody"};
  static constexpr unsigned long variant{20};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskBody,SgAdaTaskSpec*,&SgAdaTaskBody::p_spec>, describe_field_t<SgAdaTaskBody,SgStatementPtrList,&SgAdaTaskBody::p_statements>>;
};
template <> struct node_from_variant_t<20> { using type = SgAdaTaskBody; };

// Class: AdaTaskBodyDecl
template <> struct describe_field_t<SgAdaTaskBodyDecl,SgName,&SgAdaTaskBodyDecl::p_name> {
  using parent = SgAdaTaskBodyDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskBodyDecl, SgName SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_name>;
};
template <> struct describe_field_t<SgAdaTaskBodyDecl,SgDeclarationStatement*,&SgAdaTaskBodyDecl::p_specificationDeclaration> {
  using parent = SgAdaTaskBodyDecl;
  using field_type = SgDeclarationStatement*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"specificationDeclaration"};
  static constexpr char const * const typestr{"SgDeclarationStatement*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_specificationDeclaration};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskBodyDecl, SgDeclarationStatement* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_specificationDeclaration>;
};
template <> struct describe_field_t<SgAdaTaskBodyDecl,SgAdaTaskBody*,&SgAdaTaskBodyDecl::p_definition> {
  using parent = SgAdaTaskBodyDecl;
  using field_type = SgAdaTaskBody*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"definition"};
  static constexpr char const * const typestr{"SgAdaTaskBody*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_definition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskBodyDecl, SgAdaTaskBody* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_definition>;
};
template <> struct describe_node_t<SgAdaTaskBodyDecl> {
  using node = SgAdaTaskBodyDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaTaskBodyDecl"};
  static constexpr unsigned long variant{21};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskBodyDecl,SgName,&SgAdaTaskBodyDecl::p_name>, describe_field_t<SgAdaTaskBodyDecl,SgDeclarationStatement*,&SgAdaTaskBodyDecl::p_specificationDeclaration>, describe_field_t<SgAdaTaskBodyDecl,SgAdaTaskBody*,&SgAdaTaskBodyDecl::p_definition>>;
};
template <> struct node_from_variant_t<21> { using type = SgAdaTaskBodyDecl; };

// Class: AdaTaskSpec
template <> struct describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body> {
  using parent = SgAdaTaskSpec;
  using field_type = SgAdaTaskBody*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAdaTaskBody*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpec, SgAdaTaskBody* SgAdaTaskSpec::*, &SgAdaTaskSpec::p_body>;
};
template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasMembers> {
  using parent = SgAdaTaskSpec;
  using field_type = bool;
  static constexpr size_t position{1};
  static constexpr char const * const name{"hasMembers"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasMembers};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasMembers>;
};
template <> struct describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations> {
  using parent = SgAdaTaskSpec;
  using field_type = SgDeclarationStatementPtrList;
  static constexpr size_t position{2};
  static constexpr char const * const name{"declarations"};
  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_declarations};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpec, SgDeclarationStatementPtrList SgAdaTaskSpec::*, &SgAdaTaskSpec::p_declarations>;
};
template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate> {
  using parent = SgAdaTaskSpec;
  using field_type = bool;
  static constexpr size_t position{3};
  static constexpr char const * const name{"hasPrivate"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasPrivate};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasPrivate>;
};
template <> struct describe_node_t<SgAdaTaskSpec> {
  using node = SgAdaTaskSpec;
  using base = SgScopeStatement;
  static constexpr char const * const name{"AdaTaskSpec"};
  static constexpr unsigned long variant{22};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body>, describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasMembers>, describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations>, describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate>>;
};
template <> struct node_from_variant_t<22> { using type = SgAdaTaskSpec; };

// Class: AdaTaskSpecDecl
template <> struct describe_field_t<SgAdaTaskSpecDecl,SgName,&SgAdaTaskSpecDecl::p_name> {
  using parent = SgAdaTaskSpecDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpecDecl, SgName SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_name>;
};
template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskSpec*,&SgAdaTaskSpecDecl::p_definition> {
  using parent = SgAdaTaskSpecDecl;
  using field_type = SgAdaTaskSpec*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"definition"};
  static constexpr char const * const typestr{"SgAdaTaskSpec*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_definition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskSpec* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_definition>;
};
template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskType*,&SgAdaTaskSpecDecl::p_type> {
  using parent = SgAdaTaskSpecDecl;
  using field_type = SgAdaTaskType*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"type"};
  static constexpr char const * const typestr{"SgAdaTaskType*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskType* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_type>;
};
template <> struct describe_node_t<SgAdaTaskSpecDecl> {
  using node = SgAdaTaskSpecDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaTaskSpecDecl"};
  static constexpr unsigned long variant{23};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskSpecDecl,SgName,&SgAdaTaskSpecDecl::p_name>, describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskSpec*,&SgAdaTaskSpecDecl::p_definition>, describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskType*,&SgAdaTaskSpecDecl::p_type>>;
};
template <> struct node_from_variant_t<23> { using type = SgAdaTaskSpecDecl; };

// Class: AdaTaskSymbol
template <> struct describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration> {
  using parent = SgAdaTaskSymbol;
  using field_type = SgDeclarationStatement*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"declaration"};
  static constexpr char const * const typestr{"SgDeclarationStatement*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskSymbol::p_declaration};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskSymbol, SgDeclarationStatement* SgAdaTaskSymbol::*, &SgAdaTaskSymbol::p_declaration>;
};
template <> struct describe_node_t<SgAdaTaskSymbol> {
  using node = SgAdaTaskSymbol;
  using base = SgSymbol;
  static constexpr char const * const name{"AdaTaskSymbol"};
  static constexpr unsigned long variant{24};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration>>;
};
template <> struct node_from_variant_t<24> { using type = SgAdaTaskSymbol; };

// Class: AdaTaskRefExp
template <> struct describe_field_t<SgAdaTaskRefExp,SgAdaTaskSpecDecl*,&SgAdaTaskRefExp::p_decl> {
  using parent = SgAdaTaskRefExp;
  using field_type = SgAdaTaskSpecDecl*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"decl"};
  static constexpr char const * const typestr{"SgAdaTaskSpecDecl*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskRefExp::p_decl};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskRefExp, SgAdaTaskSpecDecl* SgAdaTaskRefExp::*, &SgAdaTaskRefExp::p_decl>;
};
template <> struct describe_node_t<SgAdaTaskRefExp> {
  using node = SgAdaTaskRefExp;
  using base = SgExpression;
  static constexpr char const * const name{"AdaTaskRefExp"};
  static constexpr unsigned long variant{25};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskRefExp,SgAdaTaskSpecDecl*,&SgAdaTaskRefExp::p_decl>>;
};
template <> struct node_from_variant_t<25> { using type = SgAdaTaskRefExp; };

// Class: AdaTaskType
template <> struct describe_node_t<SgAdaTaskType> {
  using node = SgAdaTaskType;
  using base = SgNamedType;
  static constexpr char const * const name{"AdaTaskType"};
  static constexpr unsigned long variant{26};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<26> { using type = SgAdaTaskType; };

// Class: AdaTaskTypeDecl
template <> struct describe_field_t<SgAdaTaskTypeDecl,SgName,&SgAdaTaskTypeDecl::p_name> {
  using parent = SgAdaTaskTypeDecl;
  using field_type = SgName;
  static constexpr size_t position{0};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskTypeDecl, SgName SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_name>;
};
template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskSpec*,&SgAdaTaskTypeDecl::p_definition> {
  using parent = SgAdaTaskTypeDecl;
  using field_type = SgAdaTaskSpec*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"definition"};
  static constexpr char const * const typestr{"SgAdaTaskSpec*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_definition};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskSpec* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_definition>;
};
template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskType*,&SgAdaTaskTypeDecl::p_type> {
  using parent = SgAdaTaskTypeDecl;
  using field_type = SgAdaTaskType*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"type"};
  static constexpr char const * const typestr{"SgAdaTaskType*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskType* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_type>;
};
template <> struct describe_node_t<SgAdaTaskTypeDecl> {
  using node = SgAdaTaskTypeDecl;
  using base = SgDeclarationStatement;
  static constexpr char const * const name{"AdaTaskTypeDecl"};
  static constexpr unsigned long variant{27};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAdaTaskTypeDecl,SgName,&SgAdaTaskTypeDecl::p_name>, describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskSpec*,&SgAdaTaskTypeDecl::p_definition>, describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskType*,&SgAdaTaskTypeDecl::p_type>>;
};
template <> struct node_from_variant_t<27> { using type = SgAdaTaskTypeDecl; };

// Class: AdaTypeConstraint
template <> struct describe_node_t<SgAdaTypeConstraint> {
  using node = SgAdaTypeConstraint;
  using base = SgLocatedNodeSupport;
  static constexpr char const * const name{"AdaTypeConstraint"};
  static constexpr unsigned long variant{28};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAdaRangeConstraint, SgAdaIndexConstraint, SgAdaDigitsConstraint, SgAdaDeltaConstraint, SgAdaDiscriminantConstraint, SgAdaNullConstraint>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<28> { using type = SgAdaTypeConstraint; };

// Class: AddOp
template <> struct describe_node_t<SgAddOp> {
  using node = SgAddOp;
  using base = SgBinaryOp;
  static constexpr char const * const name{"AddOp"};
  static constexpr unsigned long variant{29};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<29> { using type = SgAddOp; };

// Class: AddressOfOp
template <> struct describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree> {
  using parent = SgAddressOfOp;
  using field_type = SgExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"originalExpressionTree"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAddressOfOp::p_originalExpressionTree};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAddressOfOp, SgExpression* SgAddressOfOp::*, &SgAddressOfOp::p_originalExpressionTree>;
};
template <> struct describe_node_t<SgAddressOfOp> {
  using node = SgAddressOfOp;
  using base = SgUnaryOp;
  static constexpr char const * const name{"AddressOfOp"};
  static constexpr unsigned long variant{30};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree>>;
};
template <> struct node_from_variant_t<30> { using type = SgAddressOfOp; };

// Class: AggregateInitializer
template <> struct describe_field_t<SgAggregateInitializer,SgExprListExp*,&SgAggregateInitializer::p_initializers> {
  using parent = SgAggregateInitializer;
  using field_type = SgExprListExp*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"initializers"};
  static constexpr char const * const typestr{"SgExprListExp*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_initializers};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, SgExprListExp* SgAggregateInitializer::*, &SgAggregateInitializer::p_initializers>;
};
template <> struct describe_field_t<SgAggregateInitializer,SgType*,&SgAggregateInitializer::p_expression_type> {
  using parent = SgAggregateInitializer;
  using field_type = SgType*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"expression_type"};
  static constexpr char const * const typestr{"SgType*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_expression_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, SgType* SgAggregateInitializer::*, &SgAggregateInitializer::p_expression_type>;
};
template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_need_explicit_braces> {
  using parent = SgAggregateInitializer;
  using field_type = bool;
  static constexpr size_t position{2};
  static constexpr char const * const name{"need_explicit_braces"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_need_explicit_braces};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_need_explicit_braces>;
};
template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_uses_compound_literal> {
  using parent = SgAggregateInitializer;
  using field_type = bool;
  static constexpr size_t position{3};
  static constexpr char const * const name{"uses_compound_literal"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_uses_compound_literal};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_uses_compound_literal>;
};
template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType> {
  using parent = SgAggregateInitializer;
  using field_type = bool;
  static constexpr size_t position{4};
  static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_requiresGlobalNameQualificationOnType>;
};
template <> struct describe_field_t<SgAggregateInitializer,int,&SgAggregateInitializer::p_name_qualification_length_for_type> {
  using parent = SgAggregateInitializer;
  using field_type = int;
  static constexpr size_t position{5};
  static constexpr char const * const name{"name_qualification_length_for_type"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_name_qualification_length_for_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, int SgAggregateInitializer::*, &SgAggregateInitializer::p_name_qualification_length_for_type>;
};
template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_type_elaboration_required_for_type> {
  using parent = SgAggregateInitializer;
  using field_type = bool;
  static constexpr size_t position{6};
  static constexpr char const * const name{"type_elaboration_required_for_type"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_type_elaboration_required_for_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_type_elaboration_required_for_type>;
};
template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_global_qualification_required_for_type> {
  using parent = SgAggregateInitializer;
  using field_type = bool;
  static constexpr size_t position{7};
  static constexpr char const * const name{"global_qualification_required_for_type"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_global_qualification_required_for_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_global_qualification_required_for_type>;
};
template <> struct describe_field_t<SgAggregateInitializer,SgExpression*,&SgAggregateInitializer::p_originalExpressionTree> {
  using parent = SgAggregateInitializer;
  using field_type = SgExpression*;
  static constexpr size_t position{8};
  static constexpr char const * const name{"originalExpressionTree"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_originalExpressionTree};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAggregateInitializer, SgExpression* SgAggregateInitializer::*, &SgAggregateInitializer::p_originalExpressionTree>;
};
template <> struct describe_node_t<SgAggregateInitializer> {
  using node = SgAggregateInitializer;
  using base = SgInitializer;
  static constexpr char const * const name{"AggregateInitializer"};
  static constexpr unsigned long variant{31};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAggregateInitializer,SgExprListExp*,&SgAggregateInitializer::p_initializers>, describe_field_t<SgAggregateInitializer,SgType*,&SgAggregateInitializer::p_expression_type>, describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_need_explicit_braces>, describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_uses_compound_literal>, describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType>, describe_field_t<SgAggregateInitializer,int,&SgAggregateInitializer::p_name_qualification_length_for_type>, describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_type_elaboration_required_for_type>, describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_global_qualification_required_for_type>, describe_field_t<SgAggregateInitializer,SgExpression*,&SgAggregateInitializer::p_originalExpressionTree>>;
};
template <> struct node_from_variant_t<31> { using type = SgAggregateInitializer; };

// Class: AliasSymbol
template <> struct describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias> {
  using parent = SgAliasSymbol;
  using field_type = SgSymbol*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"alias"};
  static constexpr char const * const typestr{"SgSymbol*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAliasSymbol::p_alias};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAliasSymbol, SgSymbol* SgAliasSymbol::*, &SgAliasSymbol::p_alias>;
};
template <> struct describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed> {
  using parent = SgAliasSymbol;
  using field_type = bool;
  static constexpr size_t position{1};
  static constexpr char const * const name{"isRenamed"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAliasSymbol::p_isRenamed};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAliasSymbol, bool SgAliasSymbol::*, &SgAliasSymbol::p_isRenamed>;
};
template <> struct describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name> {
  using parent = SgAliasSymbol;
  using field_type = SgName;
  static constexpr size_t position{2};
  static constexpr char const * const name{"new_name"};
  static constexpr char const * const typestr{"SgName"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAliasSymbol::p_new_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAliasSymbol, SgName SgAliasSymbol::*, &SgAliasSymbol::p_new_name>;
};
template <> struct describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes> {
  using parent = SgAliasSymbol;
  using field_type = SgNodePtrList;
  static constexpr size_t position{3};
  static constexpr char const * const name{"causal_nodes"};
  static constexpr char const * const typestr{"SgNodePtrList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAliasSymbol::p_causal_nodes};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAliasSymbol, SgNodePtrList SgAliasSymbol::*, &SgAliasSymbol::p_causal_nodes>;
};
template <> struct describe_node_t<SgAliasSymbol> {
  using node = SgAliasSymbol;
  using base = SgSymbol;
  static constexpr char const * const name{"AliasSymbol"};
  static constexpr unsigned long variant{32};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias>, describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed>, describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name>, describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes>>;
};
template <> struct node_from_variant_t<32> { using type = SgAliasSymbol; };

// Class: AllocateStatement
template <> struct describe_field_t<SgAllocateStatement,SgExprListExp*,&SgAllocateStatement::p_expr_list> {
  using parent = SgAllocateStatement;
  using field_type = SgExprListExp*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"expr_list"};
  static constexpr char const * const typestr{"SgExprListExp*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAllocateStatement::p_expr_list};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAllocateStatement, SgExprListExp* SgAllocateStatement::*, &SgAllocateStatement::p_expr_list>;
};
template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_stat_expression> {
  using parent = SgAllocateStatement;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"stat_expression"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAllocateStatement::p_stat_expression};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_stat_expression>;
};
template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_errmsg_expression> {
  using parent = SgAllocateStatement;
  using field_type = SgExpression*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"errmsg_expression"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAllocateStatement::p_errmsg_expression};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_errmsg_expression>;
};
template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_source_expression> {
  using parent = SgAllocateStatement;
  using field_type = SgExpression*;
  static constexpr size_t position{3};
  static constexpr char const * const name{"source_expression"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAllocateStatement::p_source_expression};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_source_expression>;
};
template <> struct describe_node_t<SgAllocateStatement> {
  using node = SgAllocateStatement;
  using base = SgStatement;
  static constexpr char const * const name{"AllocateStatement"};
  static constexpr unsigned long variant{33};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAllocateStatement,SgExprListExp*,&SgAllocateStatement::p_expr_list>, describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_stat_expression>, describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_errmsg_expression>, describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_source_expression>>;
};
template <> struct node_from_variant_t<33> { using type = SgAllocateStatement; };

// Class: AndAssignOp
template <> struct describe_node_t<SgAndAssignOp> {
  using node = SgAndAssignOp;
  using base = SgCompoundAssignOp;
  static constexpr char const * const name{"AndAssignOp"};
  static constexpr unsigned long variant{34};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<34> { using type = SgAndAssignOp; };

// Class: AndOp
template <> struct describe_node_t<SgAndOp> {
  using node = SgAndOp;
  using base = SgBinaryOp;
  static constexpr char const * const name{"AndOp"};
  static constexpr unsigned long variant{35};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<35> { using type = SgAndOp; };

// Class: ArithmeticIfStatement
template <> struct describe_field_t<SgArithmeticIfStatement,SgExpression*,&SgArithmeticIfStatement::p_conditional> {
  using parent = SgArithmeticIfStatement;
  using field_type = SgExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"conditional"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_conditional};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArithmeticIfStatement, SgExpression* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_conditional>;
};
template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_less_label> {
  using parent = SgArithmeticIfStatement;
  using field_type = SgLabelRefExp*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"less_label"};
  static constexpr char const * const typestr{"SgLabelRefExp*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_less_label};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_less_label>;
};
template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_equal_label> {
  using parent = SgArithmeticIfStatement;
  using field_type = SgLabelRefExp*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"equal_label"};
  static constexpr char const * const typestr{"SgLabelRefExp*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_equal_label};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_equal_label>;
};
template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_greater_label> {
  using parent = SgArithmeticIfStatement;
  using field_type = SgLabelRefExp*;
  static constexpr size_t position{3};
  static constexpr char const * const name{"greater_label"};
  static constexpr char const * const typestr{"SgLabelRefExp*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_greater_label};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_greater_label>;
};
template <> struct describe_node_t<SgArithmeticIfStatement> {
  using node = SgArithmeticIfStatement;
  using base = SgStatement;
  static constexpr char const * const name{"ArithmeticIfStatement"};
  static constexpr unsigned long variant{36};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgArithmeticIfStatement,SgExpression*,&SgArithmeticIfStatement::p_conditional>, describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_less_label>, describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_equal_label>, describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_greater_label>>;
};
template <> struct node_from_variant_t<36> { using type = SgArithmeticIfStatement; };

// Class: ArrayType
template <> struct describe_field_t<SgArrayType,SgType*,&SgArrayType::p_base_type> {
  using parent = SgArrayType;
  using field_type = SgType*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"base_type"};
  static constexpr char const * const typestr{"SgType*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArrayType::p_base_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, SgType* SgArrayType::*, &SgArrayType::p_base_type>;
};
template <> struct describe_field_t<SgArrayType,SgExpression*,&SgArrayType::p_index> {
  using parent = SgArrayType;
  using field_type = SgExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"index"};
  static constexpr char const * const typestr{"SgExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgArrayType::p_index};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, SgExpression* SgArrayType::*, &SgArrayType::p_index>;
};
template <> struct describe_field_t<SgArrayType,SgExprListExp*,&SgArrayType::p_dim_info> {
  using parent = SgArrayType;
  using field_type = SgExprListExp*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"dim_info"};
  static constexpr char const * const typestr{"SgExprListExp*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgArrayType::p_dim_info};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, SgExprListExp* SgArrayType::*, &SgArrayType::p_dim_info>;
};
template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_rank> {
  using parent = SgArrayType;
  using field_type = int;
  static constexpr size_t position{3};
  static constexpr char const * const name{"rank"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArrayType::p_rank};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_rank>;
};
template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_number_of_elements> {
  using parent = SgArrayType;
  using field_type = int;
  static constexpr size_t position{4};
  static constexpr char const * const name{"number_of_elements"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArrayType::p_number_of_elements};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_number_of_elements>;
};
template <> struct describe_field_t<SgArrayType,bool,&SgArrayType::p_is_variable_length_array> {
  using parent = SgArrayType;
  using field_type = bool;
  static constexpr size_t position{5};
  static constexpr char const * const name{"is_variable_length_array"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgArrayType::p_is_variable_length_array};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgArrayType, bool SgArrayType::*, &SgArrayType::p_is_variable_length_array>;
};
template <> struct describe_node_t<SgArrayType> {
  using node = SgArrayType;
  using base = SgType;
  static constexpr char const * const name{"ArrayType"};
  static constexpr unsigned long variant{37};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgArrayType,SgType*,&SgArrayType::p_base_type>, describe_field_t<SgArrayType,SgExpression*,&SgArrayType::p_index>, describe_field_t<SgArrayType,SgExprListExp*,&SgArrayType::p_dim_info>, describe_field_t<SgArrayType,int,&SgArrayType::p_rank>, describe_field_t<SgArrayType,int,&SgArrayType::p_number_of_elements>, describe_field_t<SgArrayType,bool,&SgArrayType::p_is_variable_length_array>>;
};
template <> struct node_from_variant_t<37> { using type = SgArrayType; };

// Class: ArrowExp
template <> struct describe_node_t<SgArrowExp> {
  using node = SgArrowExp;
  using base = SgBinaryOp;
  static constexpr char const * const name{"ArrowExp"};
  static constexpr unsigned long variant{38};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<38> { using type = SgArrowExp; };

// Class: ArrowStarOp
template <> struct describe_node_t<SgArrowStarOp> {
  using node = SgArrowStarOp;
  using base = SgBinaryOp;
  static constexpr char const * const name{"ArrowStarOp"};
  static constexpr unsigned long variant{39};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<39> { using type = SgArrowStarOp; };

// Class: AsmBasicString
template <> struct describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string> {
  using parent = SgAsmBasicString;
  using field_type = std::string;
  static constexpr size_t position{0};
  static constexpr char const * const name{"string"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBasicString::p_string};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBasicString, std::string SgAsmBasicString::*, &SgAsmBasicString::p_string>;
};
template <> struct describe_node_t<SgAsmBasicString> {
  using node = SgAsmBasicString;
  using base = SgAsmGenericString;
  static constexpr char const * const name{"AsmBasicString"};
  static constexpr unsigned long variant{46};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string>>;
};
template <> struct node_from_variant_t<46> { using type = SgAsmBasicString; };

// Class: AsmBinaryAdd
template <> struct describe_node_t<SgAsmBinaryAdd> {
  using node = SgAsmBinaryAdd;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryAdd"};
  static constexpr unsigned long variant{47};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<47> { using type = SgAsmBinaryAdd; };

// Class: AsmBinaryAsr
template <> struct describe_node_t<SgAsmBinaryAsr> {
  using node = SgAsmBinaryAsr;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryAsr"};
  static constexpr unsigned long variant{50};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<50> { using type = SgAsmBinaryAsr; };

// Class: AsmBinaryDivide
template <> struct describe_node_t<SgAsmBinaryDivide> {
  using node = SgAsmBinaryDivide;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryDivide"};
  static constexpr unsigned long variant{51};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<51> { using type = SgAsmBinaryDivide; };

// Class: AsmBinaryExpression
template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_lhs> {
  using parent = SgAsmBinaryExpression;
  using field_type = SgAsmExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"lhs"};
  static constexpr char const * const typestr{"SgAsmExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_lhs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_lhs>;
};
template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_rhs> {
  using parent = SgAsmBinaryExpression;
  using field_type = SgAsmExpression*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"rhs"};
  static constexpr char const * const typestr{"SgAsmExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_rhs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_rhs>;
};
template <> struct describe_node_t<SgAsmBinaryExpression> {
  using node = SgAsmBinaryExpression;
  using base = SgAsmExpression;
  static constexpr char const * const name{"AsmBinaryExpression"};
  static constexpr unsigned long variant{52};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAsmBinaryAdd, SgAsmBinarySubtract, SgAsmBinaryMultiply, SgAsmBinaryDivide, SgAsmBinaryMod, SgAsmBinaryPreupdate, SgAsmBinaryPostupdate, SgAsmBinaryLsl, SgAsmBinaryLsr, SgAsmBinaryAsr, SgAsmBinaryRor, SgAsmBinaryMsl, SgAsmBinaryConcat>;
  using fields_t = mp::List<describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_lhs>, describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_rhs>>;
};
template <> struct node_from_variant_t<52> { using type = SgAsmBinaryExpression; };

// Class: AsmBinaryLsl
template <> struct describe_node_t<SgAsmBinaryLsl> {
  using node = SgAsmBinaryLsl;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryLsl"};
  static constexpr unsigned long variant{53};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<53> { using type = SgAsmBinaryLsl; };

// Class: AsmBinaryLsr
template <> struct describe_node_t<SgAsmBinaryLsr> {
  using node = SgAsmBinaryLsr;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryLsr"};
  static constexpr unsigned long variant{54};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<54> { using type = SgAsmBinaryLsr; };

// Class: AsmBinaryMod
template <> struct describe_node_t<SgAsmBinaryMod> {
  using node = SgAsmBinaryMod;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryMod"};
  static constexpr unsigned long variant{55};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<55> { using type = SgAsmBinaryMod; };

// Class: AsmBinaryMsl
template <> struct describe_node_t<SgAsmBinaryMsl> {
  using node = SgAsmBinaryMsl;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryMsl"};
  static constexpr unsigned long variant{56};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<56> { using type = SgAsmBinaryMsl; };

// Class: AsmBinaryMultiply
template <> struct describe_node_t<SgAsmBinaryMultiply> {
  using node = SgAsmBinaryMultiply;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryMultiply"};
  static constexpr unsigned long variant{57};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<57> { using type = SgAsmBinaryMultiply; };

// Class: AsmBinaryRor
template <> struct describe_node_t<SgAsmBinaryRor> {
  using node = SgAsmBinaryRor;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinaryRor"};
  static constexpr unsigned long variant{58};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<58> { using type = SgAsmBinaryRor; };

// Class: AsmBinarySubtract
template <> struct describe_node_t<SgAsmBinarySubtract> {
  using node = SgAsmBinarySubtract;
  using base = SgAsmBinaryExpression;
  static constexpr char const * const name{"AsmBinarySubtract"};
  static constexpr unsigned long variant{59};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<59> { using type = SgAsmBinarySubtract; };

// Class: AsmBlock
template <> struct describe_field_t<SgAsmBlock,rose_addr_t,&SgAsmBlock::p_id> {
  using parent = SgAsmBlock;
  using field_type = rose_addr_t;
  static constexpr size_t position{0};
  static constexpr char const * const name{"id"};
  static constexpr char const * const typestr{"rose_addr_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_id};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, rose_addr_t SgAsmBlock::*, &SgAsmBlock::p_id>;
};
template <> struct describe_field_t<SgAsmBlock,unsigned,&SgAsmBlock::p_reason> {
  using parent = SgAsmBlock;
  using field_type = unsigned;
  static constexpr size_t position{1};
  static constexpr char const * const name{"reason"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_reason};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, unsigned SgAsmBlock::*, &SgAsmBlock::p_reason>;
};
template <> struct describe_field_t<SgAsmBlock,SgAsmStatementPtrList,&SgAsmBlock::p_statementList> {
  using parent = SgAsmBlock;
  using field_type = SgAsmStatementPtrList;
  static constexpr size_t position{2};
  static constexpr char const * const name{"statementList"};
  static constexpr char const * const typestr{"SgAsmStatementPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_statementList};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, SgAsmStatementPtrList SgAsmBlock::*, &SgAsmBlock::p_statementList>;
};
template <> struct describe_field_t<SgAsmBlock,SgAsmIntegerValuePtrList,&SgAsmBlock::p_successors> {
  using parent = SgAsmBlock;
  using field_type = SgAsmIntegerValuePtrList;
  static constexpr size_t position{3};
  static constexpr char const * const name{"successors"};
  static constexpr char const * const typestr{"SgAsmIntegerValuePtrList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, SgAsmIntegerValuePtrList SgAsmBlock::*, &SgAsmBlock::p_successors>;
};
template <> struct describe_field_t<SgAsmBlock,bool,&SgAsmBlock::p_successors_complete> {
  using parent = SgAsmBlock;
  using field_type = bool;
  static constexpr size_t position{4};
  static constexpr char const * const name{"successors_complete"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors_complete};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, bool SgAsmBlock::*, &SgAsmBlock::p_successors_complete>;
};
template <> struct describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediate_dominator> {
  using parent = SgAsmBlock;
  using field_type = SgAsmBlock*;
  static constexpr size_t position{5};
  static constexpr char const * const name{"immediate_dominator"};
  static constexpr char const * const typestr{"SgAsmBlock*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_immediate_dominator};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, SgAsmBlock* SgAsmBlock::*, &SgAsmBlock::p_immediate_dominator>;
};
template <> struct describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cached_vertex> {
  using parent = SgAsmBlock;
  using field_type = size_t;
  static constexpr size_t position{6};
  static constexpr char const * const name{"cached_vertex"};
  static constexpr char const * const typestr{"size_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_cached_vertex};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, size_t SgAsmBlock::*, &SgAsmBlock::p_cached_vertex>;
};
template <> struct describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_code_likelihood> {
  using parent = SgAsmBlock;
  using field_type = double;
  static constexpr size_t position{7};
  static constexpr char const * const name{"code_likelihood"};
  static constexpr char const * const typestr{"double"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_code_likelihood};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, double SgAsmBlock::*, &SgAsmBlock::p_code_likelihood>;
};
template <> struct describe_field_t<SgAsmBlock,int64_t,&SgAsmBlock::p_stackDeltaOut> {
  using parent = SgAsmBlock;
  using field_type = int64_t;
  static constexpr size_t position{8};
  static constexpr char const * const name{"stackDeltaOut"};
  static constexpr char const * const typestr{"int64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmBlock::p_stackDeltaOut};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmBlock, int64_t SgAsmBlock::*, &SgAsmBlock::p_stackDeltaOut>;
};
template <> struct describe_node_t<SgAsmBlock> {
  using node = SgAsmBlock;
  using base = SgAsmStatement;
  static constexpr char const * const name{"AsmBlock"};
  static constexpr unsigned long variant{62};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmBlock,rose_addr_t,&SgAsmBlock::p_id>, describe_field_t<SgAsmBlock,unsigned,&SgAsmBlock::p_reason>, describe_field_t<SgAsmBlock,SgAsmStatementPtrList,&SgAsmBlock::p_statementList>, describe_field_t<SgAsmBlock,SgAsmIntegerValuePtrList,&SgAsmBlock::p_successors>, describe_field_t<SgAsmBlock,bool,&SgAsmBlock::p_successors_complete>, describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediate_dominator>, describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cached_vertex>, describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_code_likelihood>, describe_field_t<SgAsmBlock,int64_t,&SgAsmBlock::p_stackDeltaOut>>;
};
template <> struct node_from_variant_t<62> { using type = SgAsmBlock; };

// Class: AsmCoffStrtab
template <> struct describe_node_t<SgAsmCoffStrtab> {
  using node = SgAsmCoffStrtab;
  using base = SgAsmGenericStrtab;
  static constexpr char const * const name{"AsmCoffStrtab"};
  static constexpr unsigned long variant{63};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<63> { using type = SgAsmCoffStrtab; };

// Class: AsmCoffSymbol
template <> struct describe_field_t<SgAsmCoffSymbol,std::string,&SgAsmCoffSymbol::p_st_name> {
  using parent = SgAsmCoffSymbol;
  using field_type = std::string;
  static constexpr size_t position{0};
  static constexpr char const * const name{"st_name"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, std::string SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,rose_addr_t,&SgAsmCoffSymbol::p_st_name_offset> {
  using parent = SgAsmCoffSymbol;
  using field_type = rose_addr_t;
  static constexpr size_t position{1};
  static constexpr char const * const name{"st_name_offset"};
  static constexpr char const * const typestr{"rose_addr_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name_offset};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, rose_addr_t SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name_offset>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,int,&SgAsmCoffSymbol::p_st_section_num> {
  using parent = SgAsmCoffSymbol;
  using field_type = int;
  static constexpr size_t position{2};
  static constexpr char const * const name{"st_section_num"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_section_num};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, int SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_section_num>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_type> {
  using parent = SgAsmCoffSymbol;
  using field_type = unsigned;
  static constexpr size_t position{3};
  static constexpr char const * const name{"st_type"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_type};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_type>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_storage_class> {
  using parent = SgAsmCoffSymbol;
  using field_type = unsigned;
  static constexpr size_t position{4};
  static constexpr char const * const name{"st_storage_class"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_storage_class};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_storage_class>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_num_aux_entries> {
  using parent = SgAsmCoffSymbol;
  using field_type = unsigned;
  static constexpr size_t position{5};
  static constexpr char const * const name{"st_num_aux_entries"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_num_aux_entries};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_num_aux_entries>;
};
template <> struct describe_field_t<SgAsmCoffSymbol,SgUnsignedCharList,&SgAsmCoffSymbol::p_aux_data> {
  using parent = SgAsmCoffSymbol;
  using field_type = SgUnsignedCharList;
  static constexpr size_t position{6};
  static constexpr char const * const name{"aux_data"};
  static constexpr char const * const typestr{"SgUnsignedCharList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_aux_data};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbol, SgUnsignedCharList SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_aux_data>;
};
template <> struct describe_node_t<SgAsmCoffSymbol> {
  using node = SgAsmCoffSymbol;
  using base = SgAsmGenericSymbol;
  static constexpr char const * const name{"AsmCoffSymbol"};
  static constexpr unsigned long variant{64};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmCoffSymbol,std::string,&SgAsmCoffSymbol::p_st_name>, describe_field_t<SgAsmCoffSymbol,rose_addr_t,&SgAsmCoffSymbol::p_st_name_offset>, describe_field_t<SgAsmCoffSymbol,int,&SgAsmCoffSymbol::p_st_section_num>, describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_type>, describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_storage_class>, describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_num_aux_entries>, describe_field_t<SgAsmCoffSymbol,SgUnsignedCharList,&SgAsmCoffSymbol::p_aux_data>>;
};
template <> struct node_from_variant_t<64> { using type = SgAsmCoffSymbol; };

// Class: AsmCoffSymbolList
template <> struct describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols> {
  using parent = SgAsmCoffSymbolList;
  using field_type = SgAsmCoffSymbolPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"symbols"};
  static constexpr char const * const typestr{"SgAsmCoffSymbolPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbolList::p_symbols};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbolList, SgAsmCoffSymbolPtrList SgAsmCoffSymbolList::*, &SgAsmCoffSymbolList::p_symbols>;
};
template <> struct describe_node_t<SgAsmCoffSymbolList> {
  using node = SgAsmCoffSymbolList;
  using base = SgAsmExecutableFileFormat;
  static constexpr char const * const name{"AsmCoffSymbolList"};
  static constexpr unsigned long variant{65};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols>>;
};
template <> struct node_from_variant_t<65> { using type = SgAsmCoffSymbolList; };

// Class: AsmCoffSymbolTable
template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab> {
  using parent = SgAsmCoffSymbolTable;
  using field_type = SgAsmGenericSection*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"strtab"};
  static constexpr char const * const typestr{"SgAsmGenericSection*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_strtab};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbolTable, SgAsmGenericSection* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_strtab>;
};
template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols> {
  using parent = SgAsmCoffSymbolTable;
  using field_type = SgAsmCoffSymbolList*;
  static constexpr size_t position{1};
  static constexpr char const * const name{"symbols"};
  static constexpr char const * const typestr{"SgAsmCoffSymbolList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_symbols};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCoffSymbolTable, SgAsmCoffSymbolList* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_symbols>;
};
template <> struct describe_node_t<SgAsmCoffSymbolTable> {
  using node = SgAsmCoffSymbolTable;
  using base = SgAsmGenericSection;
  static constexpr char const * const name{"AsmCoffSymbolTable"};
  static constexpr unsigned long variant{66};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab>, describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols>>;
};
template <> struct node_from_variant_t<66> { using type = SgAsmCoffSymbolTable; };

// Class: AsmCommonSubExpression
template <> struct describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression> {
  using parent = SgAsmCommonSubExpression;
  using field_type = SgAsmExpression*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"subexpression"};
  static constexpr char const * const typestr{"SgAsmExpression*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmCommonSubExpression::p_subexpression};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmCommonSubExpression, SgAsmExpression* SgAsmCommonSubExpression::*, &SgAsmCommonSubExpression::p_subexpression>;
};
template <> struct describe_node_t<SgAsmCommonSubExpression> {
  using node = SgAsmCommonSubExpression;
  using base = SgAsmExpression;
  static constexpr char const * const name{"AsmCommonSubExpression"};
  static constexpr unsigned long variant{67};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression>>;
};
template <> struct node_from_variant_t<67> { using type = SgAsmCommonSubExpression; };

// Class: AsmControlFlagsExpression
template <> struct describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bit_flags> {
  using parent = SgAsmControlFlagsExpression;
  using field_type = unsigned long;
  static constexpr size_t position{0};
  static constexpr char const * const name{"bit_flags"};
  static constexpr char const * const typestr{"unsigned long"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmControlFlagsExpression::p_bit_flags};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmControlFlagsExpression, unsigned long SgAsmControlFlagsExpression::*, &SgAsmControlFlagsExpression::p_bit_flags>;
};
template <> struct describe_node_t<SgAsmControlFlagsExpression> {
  using node = SgAsmControlFlagsExpression;
  using base = SgAsmExpression;
  static constexpr char const * const name{"AsmControlFlagsExpression"};
  static constexpr unsigned long variant{68};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bit_flags>>;
};
template <> struct node_from_variant_t<68> { using type = SgAsmControlFlagsExpression; };

// Class: AsmConstantExpression
template <> struct describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector> {
  using parent = SgAsmConstantExpression;
  using field_type = Sawyer::Container::BitVector;
  static constexpr size_t position{0};
  static constexpr char const * const name{"bitVector"};
  static constexpr char const * const typestr{"Sawyer::Container::BitVector"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmConstantExpression::p_bitVector};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmConstantExpression, Sawyer::Container::BitVector SgAsmConstantExpression::*, &SgAsmConstantExpression::p_bitVector>;
};
template <> struct describe_node_t<SgAsmConstantExpression> {
  using node = SgAsmConstantExpression;
  using base = SgAsmValueExpression;
  static constexpr char const * const name{"AsmConstantExpression"};
  static constexpr unsigned long variant{69};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAsmIntegerValueExpression, SgAsmFloatValueExpression>;
  using fields_t = mp::List<describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector>>;
};
template <> struct node_from_variant_t<69> { using type = SgAsmConstantExpression; };

// Class: AsmDOSExtendedHeader
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res1> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{0};
  static constexpr char const * const name{"e_res1"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res1};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res1>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oemid> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{1};
  static constexpr char const * const name{"e_oemid"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oemid};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oemid>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oeminfo> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{2};
  static constexpr char const * const name{"e_oeminfo"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oeminfo};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oeminfo>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res2> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{3};
  static constexpr char const * const name{"e_res2"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res2};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res2>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res3> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{4};
  static constexpr char const * const name{"e_res3"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res3};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res3>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res4> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{5};
  static constexpr char const * const name{"e_res4"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res4};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res4>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res5> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{6};
  static constexpr char const * const name{"e_res5"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res5};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res5>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res6> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = unsigned;
  static constexpr size_t position{7};
  static constexpr char const * const name{"e_res6"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res6};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res6>;
};
template <> struct describe_field_t<SgAsmDOSExtendedHeader,rose_addr_t,&SgAsmDOSExtendedHeader::p_e_lfanew> {
  using parent = SgAsmDOSExtendedHeader;
  using field_type = rose_addr_t;
  static constexpr size_t position{8};
  static constexpr char const * const name{"e_lfanew"};
  static constexpr char const * const typestr{"rose_addr_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_lfanew};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSExtendedHeader, rose_addr_t SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_lfanew>;
};
template <> struct describe_node_t<SgAsmDOSExtendedHeader> {
  using node = SgAsmDOSExtendedHeader;
  using base = SgAsmGenericSection;
  static constexpr char const * const name{"AsmDOSExtendedHeader"};
  static constexpr unsigned long variant{70};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res1>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oemid>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oeminfo>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res2>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res3>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res4>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res5>, describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res6>, describe_field_t<SgAsmDOSExtendedHeader,rose_addr_t,&SgAsmDOSExtendedHeader::p_e_lfanew>>;
};
template <> struct node_from_variant_t<70> { using type = SgAsmDOSExtendedHeader; };

// Class: AsmDOSFileHeader
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{0};
  static constexpr char const * const name{"e_last_page_size"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_last_page_size};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_last_page_size>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{1};
  static constexpr char const * const name{"e_total_pages"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_total_pages};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_total_pages>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{2};
  static constexpr char const * const name{"e_nrelocs"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_nrelocs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_nrelocs>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{3};
  static constexpr char const * const name{"e_header_paragraphs"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_header_paragraphs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_header_paragraphs>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{4};
  static constexpr char const * const name{"e_minalloc"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_minalloc};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_minalloc>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{5};
  static constexpr char const * const name{"e_maxalloc"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_maxalloc};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_maxalloc>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{6};
  static constexpr char const * const name{"e_ss"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ss};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ss>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{7};
  static constexpr char const * const name{"e_sp"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_sp};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_sp>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{8};
  static constexpr char const * const name{"e_cksum"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cksum};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cksum>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{9};
  static constexpr char const * const name{"e_ip"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ip};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ip>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{10};
  static constexpr char const * const name{"e_cs"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cs>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay> {
  using parent = SgAsmDOSFileHeader;
  using field_type = uint16_t;
  static constexpr size_t position{11};
  static constexpr char const * const name{"e_overlay"};
  static constexpr char const * const typestr{"uint16_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_overlay};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_overlay>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,rose_addr_t,&SgAsmDOSFileHeader::p_e_relocs_offset> {
  using parent = SgAsmDOSFileHeader;
  using field_type = rose_addr_t;
  static constexpr size_t position{12};
  static constexpr char const * const name{"e_relocs_offset"};
  static constexpr char const * const typestr{"rose_addr_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_relocs_offset};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, rose_addr_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_relocs_offset>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1> {
  using parent = SgAsmDOSFileHeader;
  using field_type = unsigned;
  static constexpr size_t position{13};
  static constexpr char const * const name{"e_res1"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_res1};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, unsigned SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_res1>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs> {
  using parent = SgAsmDOSFileHeader;
  using field_type = SgAsmGenericSection*;
  static constexpr size_t position{14};
  static constexpr char const * const name{"relocs"};
  static constexpr char const * const typestr{"SgAsmGenericSection*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_relocs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_relocs>;
};
template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section> {
  using parent = SgAsmDOSFileHeader;
  using field_type = SgAsmGenericSection*;
  static constexpr size_t position{15};
  static constexpr char const * const name{"rm_section"};
  static constexpr char const * const typestr{"SgAsmGenericSection*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_rm_section};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_rm_section>;
};
template <> struct describe_node_t<SgAsmDOSFileHeader> {
  using node = SgAsmDOSFileHeader;
  using base = SgAsmGenericHeader;
  static constexpr char const * const name{"AsmDOSFileHeader"};
  static constexpr unsigned long variant{71};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay>, describe_field_t<SgAsmDOSFileHeader,rose_addr_t,&SgAsmDOSFileHeader::p_e_relocs_offset>, describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1>, describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs>, describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section>>;
};
template <> struct node_from_variant_t<71> { using type = SgAsmDOSFileHeader; };

// Class: AsmSynthesizedDataStructureDeclaration
template <> struct describe_node_t<SgAsmSynthesizedDataStructureDeclaration> {
  using node = SgAsmSynthesizedDataStructureDeclaration;
  using base = SgAsmSynthesizedDeclaration;
  static constexpr char const * const name{"AsmSynthesizedDataStructureDeclaration"};
  static constexpr unsigned long variant{72};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<72> { using type = SgAsmSynthesizedDataStructureDeclaration; };

// Class: AsmSynthesizedDeclaration
template <> struct describe_node_t<SgAsmSynthesizedDeclaration> {
  using node = SgAsmSynthesizedDeclaration;
  using base = SgAsmStatement;
  static constexpr char const * const name{"AsmSynthesizedDeclaration"};
  static constexpr unsigned long variant{73};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAsmSynthesizedDataStructureDeclaration, SgAsmFunction, SgAsmSynthesizedFieldDeclaration>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<73> { using type = SgAsmSynthesizedDeclaration; };

// Class: AsmDirectRegisterExpression
template <> struct describe_node_t<SgAsmDirectRegisterExpression> {
  using node = SgAsmDirectRegisterExpression;
  using base = SgAsmRegisterReferenceExpression;
  static constexpr char const * const name{"AsmDirectRegisterExpression"};
  static constexpr unsigned long variant{74};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<74> { using type = SgAsmDirectRegisterExpression; };

// Class: AsmDwarfAccessDeclaration
template <> struct describe_node_t<SgAsmDwarfAccessDeclaration> {
  using node = SgAsmDwarfAccessDeclaration;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfAccessDeclaration"};
  static constexpr unsigned long variant{75};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<75> { using type = SgAsmDwarfAccessDeclaration; };

// Class: AsmDwarfArrayType
template <> struct describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body> {
  using parent = SgAsmDwarfArrayType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfArrayType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfArrayType, SgAsmDwarfConstructList* SgAsmDwarfArrayType::*, &SgAsmDwarfArrayType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfArrayType> {
  using node = SgAsmDwarfArrayType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfArrayType"};
  static constexpr unsigned long variant{76};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body>>;
};
template <> struct node_from_variant_t<76> { using type = SgAsmDwarfArrayType; };

// Class: AsmDwarfBaseType
template <> struct describe_node_t<SgAsmDwarfBaseType> {
  using node = SgAsmDwarfBaseType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfBaseType"};
  static constexpr unsigned long variant{77};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<77> { using type = SgAsmDwarfBaseType; };

// Class: AsmDwarfCatchBlock
template <> struct describe_node_t<SgAsmDwarfCatchBlock> {
  using node = SgAsmDwarfCatchBlock;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfCatchBlock"};
  static constexpr unsigned long variant{78};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<78> { using type = SgAsmDwarfCatchBlock; };

// Class: AsmDwarfClassTemplate
template <> struct describe_node_t<SgAsmDwarfClassTemplate> {
  using node = SgAsmDwarfClassTemplate;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfClassTemplate"};
  static constexpr unsigned long variant{79};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<79> { using type = SgAsmDwarfClassTemplate; };

// Class: AsmDwarfClassType
template <> struct describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body> {
  using parent = SgAsmDwarfClassType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfClassType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfClassType, SgAsmDwarfConstructList* SgAsmDwarfClassType::*, &SgAsmDwarfClassType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfClassType> {
  using node = SgAsmDwarfClassType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfClassType"};
  static constexpr unsigned long variant{80};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body>>;
};
template <> struct node_from_variant_t<80> { using type = SgAsmDwarfClassType; };

// Class: AsmDwarfCommonBlock
template <> struct describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body> {
  using parent = SgAsmDwarfCommonBlock;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfCommonBlock::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCommonBlock, SgAsmDwarfConstructList* SgAsmDwarfCommonBlock::*, &SgAsmDwarfCommonBlock::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfCommonBlock> {
  using node = SgAsmDwarfCommonBlock;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfCommonBlock"};
  static constexpr unsigned long variant{81};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body>>;
};
template <> struct node_from_variant_t<81> { using type = SgAsmDwarfCommonBlock; };

// Class: AsmDwarfCommonInclusion
template <> struct describe_node_t<SgAsmDwarfCommonInclusion> {
  using node = SgAsmDwarfCommonInclusion;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfCommonInclusion"};
  static constexpr unsigned long variant{82};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<82> { using type = SgAsmDwarfCommonInclusion; };

// Class: AsmDwarfCompilationUnit
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_producer> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = std::string;
  static constexpr size_t position{0};
  static constexpr char const * const name{"producer"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_producer};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_producer>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_language> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = std::string;
  static constexpr size_t position{1};
  static constexpr char const * const name{"language"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_low_pc> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = uint64_t;
  static constexpr size_t position{2};
  static constexpr char const * const name{"low_pc"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_low_pc};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_low_pc>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_hi_pc> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = uint64_t;
  static constexpr size_t position{3};
  static constexpr char const * const name{"hi_pc"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_hi_pc};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_hi_pc>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,int,&SgAsmDwarfCompilationUnit::p_version_stamp> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = int;
  static constexpr size_t position{4};
  static constexpr char const * const name{"version_stamp"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_version_stamp};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, int SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_version_stamp>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_abbrev_offset> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = uint64_t;
  static constexpr size_t position{5};
  static constexpr char const * const name{"abbrev_offset"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_abbrev_offset};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_abbrev_offset>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_address_size> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = uint64_t;
  static constexpr size_t position{6};
  static constexpr char const * const name{"address_size"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_address_size};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_address_size>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_offset_length> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = uint64_t;
  static constexpr size_t position{7};
  static constexpr char const * const name{"offset_length"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_offset_length};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_offset_length>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfLineList*,&SgAsmDwarfCompilationUnit::p_line_info> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = SgAsmDwarfLineList*;
  static constexpr size_t position{8};
  static constexpr char const * const name{"line_info"};
  static constexpr char const * const typestr{"SgAsmDwarfLineList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_line_info};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfLineList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_line_info>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfConstructList*,&SgAsmDwarfCompilationUnit::p_language_constructs> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{9};
  static constexpr char const * const name{"language_constructs"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language_constructs};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfConstructList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language_constructs>;
};
template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfMacroList*,&SgAsmDwarfCompilationUnit::p_macro_info> {
  using parent = SgAsmDwarfCompilationUnit;
  using field_type = SgAsmDwarfMacroList*;
  static constexpr size_t position{10};
  static constexpr char const * const name{"macro_info"};
  static constexpr char const * const typestr{"SgAsmDwarfMacroList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_macro_info};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfMacroList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_macro_info>;
};
template <> struct describe_node_t<SgAsmDwarfCompilationUnit> {
  using node = SgAsmDwarfCompilationUnit;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfCompilationUnit"};
  static constexpr unsigned long variant{83};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_producer>, describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_language>, describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_low_pc>, describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_hi_pc>, describe_field_t<SgAsmDwarfCompilationUnit,int,&SgAsmDwarfCompilationUnit::p_version_stamp>, describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_abbrev_offset>, describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_address_size>, describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_offset_length>, describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfLineList*,&SgAsmDwarfCompilationUnit::p_line_info>, describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfConstructList*,&SgAsmDwarfCompilationUnit::p_language_constructs>, describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfMacroList*,&SgAsmDwarfCompilationUnit::p_macro_info>>;
};
template <> struct node_from_variant_t<83> { using type = SgAsmDwarfCompilationUnit; };

// Class: AsmDwarfCompilationUnitList
template <> struct describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list> {
  using parent = SgAsmDwarfCompilationUnitList;
  using field_type = SgAsmDwarfCompilationUnitPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"cu_list"};
  static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnitList::p_cu_list};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfCompilationUnitList, SgAsmDwarfCompilationUnitPtrList SgAsmDwarfCompilationUnitList::*, &SgAsmDwarfCompilationUnitList::p_cu_list>;
};
template <> struct describe_node_t<SgAsmDwarfCompilationUnitList> {
  using node = SgAsmDwarfCompilationUnitList;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfCompilationUnitList"};
  static constexpr unsigned long variant{84};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list>>;
};
template <> struct node_from_variant_t<84> { using type = SgAsmDwarfCompilationUnitList; };

// Class: AsmDwarfCondition
template <> struct describe_node_t<SgAsmDwarfCondition> {
  using node = SgAsmDwarfCondition;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfCondition"};
  static constexpr unsigned long variant{85};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<85> { using type = SgAsmDwarfCondition; };

// Class: AsmDwarfConstType
template <> struct describe_node_t<SgAsmDwarfConstType> {
  using node = SgAsmDwarfConstType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfConstType"};
  static constexpr unsigned long variant{86};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<86> { using type = SgAsmDwarfConstType; };

// Class: AsmDwarfConstant
template <> struct describe_node_t<SgAsmDwarfConstant> {
  using node = SgAsmDwarfConstant;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfConstant"};
  static constexpr unsigned long variant{87};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<87> { using type = SgAsmDwarfConstant; };

// Class: AsmDwarfConstruct
template <> struct describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level> {
  using parent = SgAsmDwarfConstruct;
  using field_type = int;
  static constexpr size_t position{0};
  static constexpr char const * const name{"nesting_level"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_nesting_level};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, int SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_nesting_level>;
};
template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset> {
  using parent = SgAsmDwarfConstruct;
  using field_type = uint64_t;
  static constexpr size_t position{1};
  static constexpr char const * const name{"offset"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_offset};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_offset>;
};
template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset> {
  using parent = SgAsmDwarfConstruct;
  using field_type = uint64_t;
  static constexpr size_t position{2};
  static constexpr char const * const name{"overall_offset"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_overall_offset};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_overall_offset>;
};
template <> struct describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name> {
  using parent = SgAsmDwarfConstruct;
  using field_type = std::string;
  static constexpr size_t position{3};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, std::string SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_name>;
};
template <> struct describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position> {
  using parent = SgAsmDwarfConstruct;
  using field_type = SgAsmDwarfLine*;
  static constexpr size_t position{4};
  static constexpr char const * const name{"source_position"};
  static constexpr char const * const typestr{"SgAsmDwarfLine*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_source_position};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, SgAsmDwarfLine* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_source_position>;
};
template <> struct describe_field_t<SgAsmDwarfConstruct,AstAttributeMechanism*,&SgAsmDwarfConstruct::p_attributeMechanism> {
  using parent = SgAsmDwarfConstruct;
  using field_type = AstAttributeMechanism*;
  static constexpr size_t position{5};
  static constexpr char const * const name{"attributeMechanism"};
  static constexpr char const * const typestr{"AstAttributeMechanism*"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_attributeMechanism};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstruct, AstAttributeMechanism* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_attributeMechanism>;
};
template <> struct describe_node_t<SgAsmDwarfConstruct> {
  using node = SgAsmDwarfConstruct;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfConstruct"};
  static constexpr unsigned long variant{88};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAsmDwarfArrayType, SgAsmDwarfClassType, SgAsmDwarfEntryPoint, SgAsmDwarfEnumerationType, SgAsmDwarfFormalParameter, SgAsmDwarfImportedDeclaration, SgAsmDwarfLabel, SgAsmDwarfLexicalBlock, SgAsmDwarfMember, SgAsmDwarfPointerType, SgAsmDwarfReferenceType, SgAsmDwarfCompilationUnit, SgAsmDwarfStringType, SgAsmDwarfStructureType, SgAsmDwarfSubroutineType, SgAsmDwarfTypedef, SgAsmDwarfUnionType, SgAsmDwarfUnspecifiedParameters, SgAsmDwarfVariant, SgAsmDwarfCommonBlock, SgAsmDwarfCommonInclusion, SgAsmDwarfInheritance, SgAsmDwarfInlinedSubroutine, SgAsmDwarfModule, SgAsmDwarfPtrToMemberType, SgAsmDwarfSetType, SgAsmDwarfSubrangeType, SgAsmDwarfWithStmt, SgAsmDwarfAccessDeclaration, SgAsmDwarfBaseType, SgAsmDwarfCatchBlock, SgAsmDwarfConstType, SgAsmDwarfConstant, SgAsmDwarfEnumerator, SgAsmDwarfFileType, SgAsmDwarfFriend, SgAsmDwarfNamelist, SgAsmDwarfNamelistItem, SgAsmDwarfPackedType, SgAsmDwarfSubprogram, SgAsmDwarfTemplateTypeParameter, SgAsmDwarfTemplateValueParameter, SgAsmDwarfThrownType, SgAsmDwarfTryBlock, SgAsmDwarfVariantPart, SgAsmDwarfVariable, SgAsmDwarfVolatileType, SgAsmDwarfDwarfProcedure, SgAsmDwarfRestrictType, SgAsmDwarfInterfaceType, SgAsmDwarfNamespace, SgAsmDwarfImportedModule, SgAsmDwarfUnspecifiedType, SgAsmDwarfPartialUnit, SgAsmDwarfImportedUnit, SgAsmDwarfMutableType, SgAsmDwarfCondition, SgAsmDwarfSharedType, SgAsmDwarfFormatLabel, SgAsmDwarfFunctionTemplate, SgAsmDwarfClassTemplate, SgAsmDwarfUpcSharedType, SgAsmDwarfUpcStrictType, SgAsmDwarfUpcRelaxedType, SgAsmDwarfUnknownConstruct>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level>, describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset>, describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset>, describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name>, describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position>, describe_field_t<SgAsmDwarfConstruct,AstAttributeMechanism*,&SgAsmDwarfConstruct::p_attributeMechanism>>;
};
template <> struct node_from_variant_t<88> { using type = SgAsmDwarfConstruct; };

// Class: AsmDwarfConstructList
template <> struct describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list> {
  using parent = SgAsmDwarfConstructList;
  using field_type = SgAsmDwarfConstructPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"list"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfConstructList::p_list};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfConstructList, SgAsmDwarfConstructPtrList SgAsmDwarfConstructList::*, &SgAsmDwarfConstructList::p_list>;
};
template <> struct describe_node_t<SgAsmDwarfConstructList> {
  using node = SgAsmDwarfConstructList;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfConstructList"};
  static constexpr unsigned long variant{89};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list>>;
};
template <> struct node_from_variant_t<89> { using type = SgAsmDwarfConstructList; };

// Class: AsmDwarfDwarfProcedure
template <> struct describe_node_t<SgAsmDwarfDwarfProcedure> {
  using node = SgAsmDwarfDwarfProcedure;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfDwarfProcedure"};
  static constexpr unsigned long variant{90};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<90> { using type = SgAsmDwarfDwarfProcedure; };

// Class: AsmDwarfEntryPoint
template <> struct describe_node_t<SgAsmDwarfEntryPoint> {
  using node = SgAsmDwarfEntryPoint;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfEntryPoint"};
  static constexpr unsigned long variant{91};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<91> { using type = SgAsmDwarfEntryPoint; };

// Class: AsmDwarfEnumerationType
template <> struct describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body> {
  using parent = SgAsmDwarfEnumerationType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfEnumerationType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfEnumerationType, SgAsmDwarfConstructList* SgAsmDwarfEnumerationType::*, &SgAsmDwarfEnumerationType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfEnumerationType> {
  using node = SgAsmDwarfEnumerationType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfEnumerationType"};
  static constexpr unsigned long variant{92};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body>>;
};
template <> struct node_from_variant_t<92> { using type = SgAsmDwarfEnumerationType; };

// Class: AsmDwarfEnumerator
template <> struct describe_node_t<SgAsmDwarfEnumerator> {
  using node = SgAsmDwarfEnumerator;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfEnumerator"};
  static constexpr unsigned long variant{93};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<93> { using type = SgAsmDwarfEnumerator; };

// Class: AsmDwarfFileType
template <> struct describe_node_t<SgAsmDwarfFileType> {
  using node = SgAsmDwarfFileType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfFileType"};
  static constexpr unsigned long variant{94};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<94> { using type = SgAsmDwarfFileType; };

// Class: AsmDwarfFormalParameter
template <> struct describe_node_t<SgAsmDwarfFormalParameter> {
  using node = SgAsmDwarfFormalParameter;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfFormalParameter"};
  static constexpr unsigned long variant{95};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<95> { using type = SgAsmDwarfFormalParameter; };

// Class: AsmDwarfFormatLabel
template <> struct describe_node_t<SgAsmDwarfFormatLabel> {
  using node = SgAsmDwarfFormatLabel;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfFormatLabel"};
  static constexpr unsigned long variant{96};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<96> { using type = SgAsmDwarfFormatLabel; };

// Class: AsmDwarfFriend
template <> struct describe_node_t<SgAsmDwarfFriend> {
  using node = SgAsmDwarfFriend;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfFriend"};
  static constexpr unsigned long variant{97};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<97> { using type = SgAsmDwarfFriend; };

// Class: AsmDwarfFunctionTemplate
template <> struct describe_node_t<SgAsmDwarfFunctionTemplate> {
  using node = SgAsmDwarfFunctionTemplate;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfFunctionTemplate"};
  static constexpr unsigned long variant{98};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<98> { using type = SgAsmDwarfFunctionTemplate; };

// Class: AsmDwarfImportedDeclaration
template <> struct describe_node_t<SgAsmDwarfImportedDeclaration> {
  using node = SgAsmDwarfImportedDeclaration;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfImportedDeclaration"};
  static constexpr unsigned long variant{99};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<99> { using type = SgAsmDwarfImportedDeclaration; };

// Class: AsmDwarfImportedModule
template <> struct describe_node_t<SgAsmDwarfImportedModule> {
  using node = SgAsmDwarfImportedModule;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfImportedModule"};
  static constexpr unsigned long variant{100};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<100> { using type = SgAsmDwarfImportedModule; };

// Class: AsmDwarfImportedUnit
template <> struct describe_node_t<SgAsmDwarfImportedUnit> {
  using node = SgAsmDwarfImportedUnit;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfImportedUnit"};
  static constexpr unsigned long variant{101};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<101> { using type = SgAsmDwarfImportedUnit; };

// Class: AsmDwarfInformation
template <> struct describe_node_t<SgAsmDwarfInformation> {
  using node = SgAsmDwarfInformation;
  using base = SgAsmExecutableFileFormat;
  static constexpr char const * const name{"AsmDwarfInformation"};
  static constexpr unsigned long variant{102};
  static constexpr bool concrete{false};
  using subclasses_t = mp::List<SgAsmDwarfMacro, SgAsmDwarfMacroList, SgAsmDwarfLine, SgAsmDwarfLineList, SgAsmDwarfCompilationUnitList, SgAsmDwarfConstruct, SgAsmDwarfConstructList>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<102> { using type = SgAsmDwarfInformation; };

// Class: AsmDwarfInheritance
template <> struct describe_node_t<SgAsmDwarfInheritance> {
  using node = SgAsmDwarfInheritance;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfInheritance"};
  static constexpr unsigned long variant{103};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<103> { using type = SgAsmDwarfInheritance; };

// Class: AsmDwarfInlinedSubroutine
template <> struct describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body> {
  using parent = SgAsmDwarfInlinedSubroutine;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfInlinedSubroutine::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfInlinedSubroutine, SgAsmDwarfConstructList* SgAsmDwarfInlinedSubroutine::*, &SgAsmDwarfInlinedSubroutine::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfInlinedSubroutine> {
  using node = SgAsmDwarfInlinedSubroutine;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfInlinedSubroutine"};
  static constexpr unsigned long variant{104};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body>>;
};
template <> struct node_from_variant_t<104> { using type = SgAsmDwarfInlinedSubroutine; };

// Class: AsmDwarfInterfaceType
template <> struct describe_node_t<SgAsmDwarfInterfaceType> {
  using node = SgAsmDwarfInterfaceType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfInterfaceType"};
  static constexpr unsigned long variant{105};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<105> { using type = SgAsmDwarfInterfaceType; };

// Class: AsmDwarfLabel
template <> struct describe_node_t<SgAsmDwarfLabel> {
  using node = SgAsmDwarfLabel;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfLabel"};
  static constexpr unsigned long variant{106};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<106> { using type = SgAsmDwarfLabel; };

// Class: AsmDwarfLexicalBlock
template <> struct describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body> {
  using parent = SgAsmDwarfLexicalBlock;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfLexicalBlock::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLexicalBlock, SgAsmDwarfConstructList* SgAsmDwarfLexicalBlock::*, &SgAsmDwarfLexicalBlock::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfLexicalBlock> {
  using node = SgAsmDwarfLexicalBlock;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfLexicalBlock"};
  static constexpr unsigned long variant{107};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body>>;
};
template <> struct node_from_variant_t<107> { using type = SgAsmDwarfLexicalBlock; };

// Class: AsmDwarfLine
template <> struct describe_field_t<SgAsmDwarfLine,uint64_t,&SgAsmDwarfLine::p_address> {
  using parent = SgAsmDwarfLine;
  using field_type = uint64_t;
  static constexpr size_t position{0};
  static constexpr char const * const name{"address"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_address};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLine, uint64_t SgAsmDwarfLine::*, &SgAsmDwarfLine::p_address>;
};
template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_file_id> {
  using parent = SgAsmDwarfLine;
  using field_type = int;
  static constexpr size_t position{1};
  static constexpr char const * const name{"file_id"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_file_id};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_file_id>;
};
template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_line> {
  using parent = SgAsmDwarfLine;
  using field_type = int;
  static constexpr size_t position{2};
  static constexpr char const * const name{"line"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_line};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_line>;
};
template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_column> {
  using parent = SgAsmDwarfLine;
  using field_type = int;
  static constexpr size_t position{3};
  static constexpr char const * const name{"column"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_column};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_column>;
};
template <> struct describe_node_t<SgAsmDwarfLine> {
  using node = SgAsmDwarfLine;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfLine"};
  static constexpr unsigned long variant{108};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfLine,uint64_t,&SgAsmDwarfLine::p_address>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_file_id>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_line>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_column>>;
};
template <> struct node_from_variant_t<108> { using type = SgAsmDwarfLine; };

// Class: AsmDwarfLineList
template <> struct describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_list> {
  using parent = SgAsmDwarfLineList;
  using field_type = SgAsmDwarfLinePtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"line_list"};
  static constexpr char const * const typestr{"SgAsmDwarfLinePtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfLineList::p_line_list};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfLineList, SgAsmDwarfLinePtrList SgAsmDwarfLineList::*, &SgAsmDwarfLineList::p_line_list>;
};
template <> struct describe_node_t<SgAsmDwarfLineList> {
  using node = SgAsmDwarfLineList;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfLineList"};
  static constexpr unsigned long variant{109};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_list>>;
};
template <> struct node_from_variant_t<109> { using type = SgAsmDwarfLineList; };

// Class: AsmDwarfMacro
template <> struct describe_field_t<SgAsmDwarfMacro,std::string,&SgAsmDwarfMacro::p_macro_string> {
  using parent = SgAsmDwarfMacro;
  using field_type = std::string;
  static constexpr size_t position{0};
  static constexpr char const * const name{"macro_string"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmDwarfMacro::p_macro_string};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfMacro, std::string SgAsmDwarfMacro::*, &SgAsmDwarfMacro::p_macro_string>;
};
template <> struct describe_node_t<SgAsmDwarfMacro> {
  using node = SgAsmDwarfMacro;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfMacro"};
  static constexpr unsigned long variant{110};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfMacro,std::string,&SgAsmDwarfMacro::p_macro_string>>;
};
template <> struct node_from_variant_t<110> { using type = SgAsmDwarfMacro; };

// Class: AsmDwarfMacroList
template <> struct describe_field_t<SgAsmDwarfMacroList,SgAsmDwarfMacroPtrList,&SgAsmDwarfMacroList::p_macro_list> {
  using parent = SgAsmDwarfMacroList;
  using field_type = SgAsmDwarfMacroPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"macro_list"};
  static constexpr char const * const typestr{"SgAsmDwarfMacroPtrList"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfMacroList::p_macro_list};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfMacroList, SgAsmDwarfMacroPtrList SgAsmDwarfMacroList::*, &SgAsmDwarfMacroList::p_macro_list>;
};
template <> struct describe_node_t<SgAsmDwarfMacroList> {
  using node = SgAsmDwarfMacroList;
  using base = SgAsmDwarfInformation;
  static constexpr char const * const name{"AsmDwarfMacroList"};
  static constexpr unsigned long variant{111};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfMacroList,SgAsmDwarfMacroPtrList,&SgAsmDwarfMacroList::p_macro_list>>;
};
template <> struct node_from_variant_t<111> { using type = SgAsmDwarfMacroList; };

// Class: AsmDwarfMember
template <> struct describe_node_t<SgAsmDwarfMember> {
  using node = SgAsmDwarfMember;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfMember"};
  static constexpr unsigned long variant{112};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<112> { using type = SgAsmDwarfMember; };

// Class: AsmDwarfModule
template <> struct describe_node_t<SgAsmDwarfModule> {
  using node = SgAsmDwarfModule;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfModule"};
  static constexpr unsigned long variant{113};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<113> { using type = SgAsmDwarfModule; };

// Class: AsmDwarfMutableType
template <> struct describe_node_t<SgAsmDwarfMutableType> {
  using node = SgAsmDwarfMutableType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfMutableType"};
  static constexpr unsigned long variant{114};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<114> { using type = SgAsmDwarfMutableType; };

// Class: AsmDwarfNamelist
template <> struct describe_node_t<SgAsmDwarfNamelist> {
  using node = SgAsmDwarfNamelist;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfNamelist"};
  static constexpr unsigned long variant{115};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<115> { using type = SgAsmDwarfNamelist; };

// Class: AsmDwarfNamelistItem
template <> struct describe_node_t<SgAsmDwarfNamelistItem> {
  using node = SgAsmDwarfNamelistItem;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfNamelistItem"};
  static constexpr unsigned long variant{116};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<116> { using type = SgAsmDwarfNamelistItem; };

// Class: AsmDwarfNamespace
template <> struct describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body> {
  using parent = SgAsmDwarfNamespace;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfNamespace::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfNamespace, SgAsmDwarfConstructList* SgAsmDwarfNamespace::*, &SgAsmDwarfNamespace::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfNamespace> {
  using node = SgAsmDwarfNamespace;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfNamespace"};
  static constexpr unsigned long variant{117};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body>>;
};
template <> struct node_from_variant_t<117> { using type = SgAsmDwarfNamespace; };

// Class: AsmDwarfPackedType
template <> struct describe_node_t<SgAsmDwarfPackedType> {
  using node = SgAsmDwarfPackedType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfPackedType"};
  static constexpr unsigned long variant{118};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<118> { using type = SgAsmDwarfPackedType; };

// Class: AsmDwarfPartialUnit
template <> struct describe_node_t<SgAsmDwarfPartialUnit> {
  using node = SgAsmDwarfPartialUnit;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfPartialUnit"};
  static constexpr unsigned long variant{119};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<119> { using type = SgAsmDwarfPartialUnit; };

// Class: AsmDwarfPointerType
template <> struct describe_node_t<SgAsmDwarfPointerType> {
  using node = SgAsmDwarfPointerType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfPointerType"};
  static constexpr unsigned long variant{120};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<120> { using type = SgAsmDwarfPointerType; };

// Class: AsmDwarfPtrToMemberType
template <> struct describe_node_t<SgAsmDwarfPtrToMemberType> {
  using node = SgAsmDwarfPtrToMemberType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfPtrToMemberType"};
  static constexpr unsigned long variant{121};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<121> { using type = SgAsmDwarfPtrToMemberType; };

// Class: AsmDwarfReferenceType
template <> struct describe_node_t<SgAsmDwarfReferenceType> {
  using node = SgAsmDwarfReferenceType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfReferenceType"};
  static constexpr unsigned long variant{122};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<122> { using type = SgAsmDwarfReferenceType; };

// Class: AsmDwarfRestrictType
template <> struct describe_node_t<SgAsmDwarfRestrictType> {
  using node = SgAsmDwarfRestrictType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfRestrictType"};
  static constexpr unsigned long variant{123};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<123> { using type = SgAsmDwarfRestrictType; };

// Class: AsmDwarfSetType
template <> struct describe_node_t<SgAsmDwarfSetType> {
  using node = SgAsmDwarfSetType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfSetType"};
  static constexpr unsigned long variant{124};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<124> { using type = SgAsmDwarfSetType; };

// Class: AsmDwarfSharedType
template <> struct describe_node_t<SgAsmDwarfSharedType> {
  using node = SgAsmDwarfSharedType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfSharedType"};
  static constexpr unsigned long variant{125};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<125> { using type = SgAsmDwarfSharedType; };

// Class: AsmDwarfStringType
template <> struct describe_node_t<SgAsmDwarfStringType> {
  using node = SgAsmDwarfStringType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfStringType"};
  static constexpr unsigned long variant{126};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<126> { using type = SgAsmDwarfStringType; };

// Class: AsmDwarfStructureType
template <> struct describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body> {
  using parent = SgAsmDwarfStructureType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfStructureType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfStructureType, SgAsmDwarfConstructList* SgAsmDwarfStructureType::*, &SgAsmDwarfStructureType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfStructureType> {
  using node = SgAsmDwarfStructureType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfStructureType"};
  static constexpr unsigned long variant{127};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body>>;
};
template <> struct node_from_variant_t<127> { using type = SgAsmDwarfStructureType; };

// Class: AsmDwarfSubprogram
template <> struct describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body> {
  using parent = SgAsmDwarfSubprogram;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfSubprogram::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfSubprogram, SgAsmDwarfConstructList* SgAsmDwarfSubprogram::*, &SgAsmDwarfSubprogram::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfSubprogram> {
  using node = SgAsmDwarfSubprogram;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfSubprogram"};
  static constexpr unsigned long variant{128};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body>>;
};
template <> struct node_from_variant_t<128> { using type = SgAsmDwarfSubprogram; };

// Class: AsmDwarfSubrangeType
template <> struct describe_node_t<SgAsmDwarfSubrangeType> {
  using node = SgAsmDwarfSubrangeType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfSubrangeType"};
  static constexpr unsigned long variant{129};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<129> { using type = SgAsmDwarfSubrangeType; };

// Class: AsmDwarfSubroutineType
template <> struct describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body> {
  using parent = SgAsmDwarfSubroutineType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfSubroutineType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfSubroutineType, SgAsmDwarfConstructList* SgAsmDwarfSubroutineType::*, &SgAsmDwarfSubroutineType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfSubroutineType> {
  using node = SgAsmDwarfSubroutineType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfSubroutineType"};
  static constexpr unsigned long variant{130};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body>>;
};
template <> struct node_from_variant_t<130> { using type = SgAsmDwarfSubroutineType; };

// Class: AsmDwarfTemplateTypeParameter
template <> struct describe_node_t<SgAsmDwarfTemplateTypeParameter> {
  using node = SgAsmDwarfTemplateTypeParameter;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfTemplateTypeParameter"};
  static constexpr unsigned long variant{131};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<131> { using type = SgAsmDwarfTemplateTypeParameter; };

// Class: AsmDwarfTemplateValueParameter
template <> struct describe_node_t<SgAsmDwarfTemplateValueParameter> {
  using node = SgAsmDwarfTemplateValueParameter;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfTemplateValueParameter"};
  static constexpr unsigned long variant{132};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<132> { using type = SgAsmDwarfTemplateValueParameter; };

// Class: AsmDwarfThrownType
template <> struct describe_node_t<SgAsmDwarfThrownType> {
  using node = SgAsmDwarfThrownType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfThrownType"};
  static constexpr unsigned long variant{133};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<133> { using type = SgAsmDwarfThrownType; };

// Class: AsmDwarfTryBlock
template <> struct describe_node_t<SgAsmDwarfTryBlock> {
  using node = SgAsmDwarfTryBlock;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfTryBlock"};
  static constexpr unsigned long variant{134};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<134> { using type = SgAsmDwarfTryBlock; };

// Class: AsmDwarfTypedef
template <> struct describe_node_t<SgAsmDwarfTypedef> {
  using node = SgAsmDwarfTypedef;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfTypedef"};
  static constexpr unsigned long variant{135};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<135> { using type = SgAsmDwarfTypedef; };

// Class: AsmDwarfUnionType
template <> struct describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body> {
  using parent = SgAsmDwarfUnionType;
  using field_type = SgAsmDwarfConstructList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"body"};
  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmDwarfUnionType::p_body};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmDwarfUnionType, SgAsmDwarfConstructList* SgAsmDwarfUnionType::*, &SgAsmDwarfUnionType::p_body>;
};
template <> struct describe_node_t<SgAsmDwarfUnionType> {
  using node = SgAsmDwarfUnionType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUnionType"};
  static constexpr unsigned long variant{136};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body>>;
};
template <> struct node_from_variant_t<136> { using type = SgAsmDwarfUnionType; };

// Class: AsmDwarfUnknownConstruct
template <> struct describe_node_t<SgAsmDwarfUnknownConstruct> {
  using node = SgAsmDwarfUnknownConstruct;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUnknownConstruct"};
  static constexpr unsigned long variant{137};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<137> { using type = SgAsmDwarfUnknownConstruct; };

// Class: AsmDwarfUnspecifiedParameters
template <> struct describe_node_t<SgAsmDwarfUnspecifiedParameters> {
  using node = SgAsmDwarfUnspecifiedParameters;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUnspecifiedParameters"};
  static constexpr unsigned long variant{138};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<138> { using type = SgAsmDwarfUnspecifiedParameters; };

// Class: AsmDwarfUnspecifiedType
template <> struct describe_node_t<SgAsmDwarfUnspecifiedType> {
  using node = SgAsmDwarfUnspecifiedType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUnspecifiedType"};
  static constexpr unsigned long variant{139};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<139> { using type = SgAsmDwarfUnspecifiedType; };

// Class: AsmDwarfUpcRelaxedType
template <> struct describe_node_t<SgAsmDwarfUpcRelaxedType> {
  using node = SgAsmDwarfUpcRelaxedType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUpcRelaxedType"};
  static constexpr unsigned long variant{140};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<140> { using type = SgAsmDwarfUpcRelaxedType; };

// Class: AsmDwarfUpcSharedType
template <> struct describe_node_t<SgAsmDwarfUpcSharedType> {
  using node = SgAsmDwarfUpcSharedType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUpcSharedType"};
  static constexpr unsigned long variant{141};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<141> { using type = SgAsmDwarfUpcSharedType; };

// Class: AsmDwarfUpcStrictType
template <> struct describe_node_t<SgAsmDwarfUpcStrictType> {
  using node = SgAsmDwarfUpcStrictType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfUpcStrictType"};
  static constexpr unsigned long variant{142};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<142> { using type = SgAsmDwarfUpcStrictType; };

// Class: AsmDwarfVariable
template <> struct describe_node_t<SgAsmDwarfVariable> {
  using node = SgAsmDwarfVariable;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfVariable"};
  static constexpr unsigned long variant{143};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<143> { using type = SgAsmDwarfVariable; };

// Class: AsmDwarfVariant
template <> struct describe_node_t<SgAsmDwarfVariant> {
  using node = SgAsmDwarfVariant;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfVariant"};
  static constexpr unsigned long variant{144};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<144> { using type = SgAsmDwarfVariant; };

// Class: AsmDwarfVariantPart
template <> struct describe_node_t<SgAsmDwarfVariantPart> {
  using node = SgAsmDwarfVariantPart;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfVariantPart"};
  static constexpr unsigned long variant{145};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<145> { using type = SgAsmDwarfVariantPart; };

// Class: AsmDwarfVolatileType
template <> struct describe_node_t<SgAsmDwarfVolatileType> {
  using node = SgAsmDwarfVolatileType;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfVolatileType"};
  static constexpr unsigned long variant{146};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<146> { using type = SgAsmDwarfVolatileType; };

// Class: AsmDwarfWithStmt
template <> struct describe_node_t<SgAsmDwarfWithStmt> {
  using node = SgAsmDwarfWithStmt;
  using base = SgAsmDwarfConstruct;
  static constexpr char const * const name{"AsmDwarfWithStmt"};
  static constexpr unsigned long variant{147};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<>;
};
template <> struct node_from_variant_t<147> { using type = SgAsmDwarfWithStmt; };

// Class: AsmElfDynamicEntry
template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmElfDynamicEntry::EntryType,&SgAsmElfDynamicEntry::p_d_tag> {
  using parent = SgAsmElfDynamicEntry;
  using field_type = SgAsmElfDynamicEntry::EntryType;
  static constexpr size_t position{0};
  static constexpr char const * const name{"d_tag"};
  static constexpr char const * const typestr{"SgAsmElfDynamicEntry::EntryType"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_tag};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicEntry, SgAsmElfDynamicEntry::EntryType SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_tag>;
};
template <> struct describe_field_t<SgAsmElfDynamicEntry,rose_rva_t,&SgAsmElfDynamicEntry::p_d_val> {
  using parent = SgAsmElfDynamicEntry;
  using field_type = rose_rva_t;
  static constexpr size_t position{1};
  static constexpr char const * const name{"d_val"};
  static constexpr char const * const typestr{"rose_rva_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_val};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicEntry, rose_rva_t SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_val>;
};
template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmGenericString*,&SgAsmElfDynamicEntry::p_name> {
  using parent = SgAsmElfDynamicEntry;
  using field_type = SgAsmGenericString*;
  static constexpr size_t position{2};
  static constexpr char const * const name{"name"};
  static constexpr char const * const typestr{"SgAsmGenericString*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_name};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicEntry, SgAsmGenericString* SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_name>;
};
template <> struct describe_field_t<SgAsmElfDynamicEntry,SgUnsignedCharList,&SgAsmElfDynamicEntry::p_extra> {
  using parent = SgAsmElfDynamicEntry;
  using field_type = SgUnsignedCharList;
  static constexpr size_t position{3};
  static constexpr char const * const name{"extra"};
  static constexpr char const * const typestr{"SgUnsignedCharList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_extra};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicEntry, SgUnsignedCharList SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_extra>;
};
template <> struct describe_node_t<SgAsmElfDynamicEntry> {
  using node = SgAsmElfDynamicEntry;
  using base = SgAsmExecutableFileFormat;
  static constexpr char const * const name{"AsmElfDynamicEntry"};
  static constexpr unsigned long variant{148};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmElfDynamicEntry,SgAsmElfDynamicEntry::EntryType,&SgAsmElfDynamicEntry::p_d_tag>, describe_field_t<SgAsmElfDynamicEntry,rose_rva_t,&SgAsmElfDynamicEntry::p_d_val>, describe_field_t<SgAsmElfDynamicEntry,SgAsmGenericString*,&SgAsmElfDynamicEntry::p_name>, describe_field_t<SgAsmElfDynamicEntry,SgUnsignedCharList,&SgAsmElfDynamicEntry::p_extra>>;
};
template <> struct node_from_variant_t<148> { using type = SgAsmElfDynamicEntry; };

// Class: AsmElfDynamicEntryList
template <> struct describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries> {
  using parent = SgAsmElfDynamicEntryList;
  using field_type = SgAsmElfDynamicEntryPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"entries"};
  static constexpr char const * const typestr{"SgAsmElfDynamicEntryPtrList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntryList::p_entries};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicEntryList, SgAsmElfDynamicEntryPtrList SgAsmElfDynamicEntryList::*, &SgAsmElfDynamicEntryList::p_entries>;
};
template <> struct describe_node_t<SgAsmElfDynamicEntryList> {
  using node = SgAsmElfDynamicEntryList;
  using base = SgAsmExecutableFileFormat;
  static constexpr char const * const name{"AsmElfDynamicEntryList"};
  static constexpr unsigned long variant{149};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries>>;
};
template <> struct node_from_variant_t<149> { using type = SgAsmElfDynamicEntryList; };

// Class: AsmElfDynamicSection
template <> struct describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries> {
  using parent = SgAsmElfDynamicSection;
  using field_type = SgAsmElfDynamicEntryList*;
  static constexpr size_t position{0};
  static constexpr char const * const name{"entries"};
  static constexpr char const * const typestr{"SgAsmElfDynamicEntryList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmElfDynamicSection::p_entries};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfDynamicSection, SgAsmElfDynamicEntryList* SgAsmElfDynamicSection::*, &SgAsmElfDynamicSection::p_entries>;
};
template <> struct describe_node_t<SgAsmElfDynamicSection> {
  using node = SgAsmElfDynamicSection;
  using base = SgAsmElfSection;
  static constexpr char const * const name{"AsmElfDynamicSection"};
  static constexpr unsigned long variant{150};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries>>;
};
template <> struct node_from_variant_t<150> { using type = SgAsmElfDynamicSection; };

// Class: AsmElfEHFrameEntryCI
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = int;
  static constexpr size_t position{0};
  static constexpr char const * const name{"version"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_version};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_version>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = std::string;
  static constexpr size_t position{1};
  static constexpr char const * const name{"augmentation_string"};
  static constexpr char const * const typestr{"std::string"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_string};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, std::string SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_string>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = uint64_t;
  static constexpr size_t position{2};
  static constexpr char const * const name{"eh_data"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_eh_data};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_eh_data>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = uint64_t;
  static constexpr size_t position{3};
  static constexpr char const * const name{"code_alignment_factor"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_code_alignment_factor};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_code_alignment_factor>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = int64_t;
  static constexpr size_t position{4};
  static constexpr char const * const name{"data_alignment_factor"};
  static constexpr char const * const typestr{"int64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_data_alignment_factor};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, int64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_data_alignment_factor>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = uint64_t;
  static constexpr size_t position{5};
  static constexpr char const * const name{"augmentation_data_length"};
  static constexpr char const * const typestr{"uint64_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_data_length};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_data_length>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = int;
  static constexpr size_t position{6};
  static constexpr char const * const name{"lsda_encoding"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_lsda_encoding};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_lsda_encoding>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = int;
  static constexpr size_t position{7};
  static constexpr char const * const name{"prh_encoding"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_encoding};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_encoding>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = unsigned;
  static constexpr size_t position{8};
  static constexpr char const * const name{"prh_arg"};
  static constexpr char const * const typestr{"unsigned"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_arg};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, unsigned SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_arg>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,rose_addr_t,&SgAsmElfEHFrameEntryCI::p_prh_addr> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = rose_addr_t;
  static constexpr size_t position{9};
  static constexpr char const * const name{"prh_addr"};
  static constexpr char const * const typestr{"rose_addr_t"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_addr};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, rose_addr_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_addr>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = int;
  static constexpr size_t position{10};
  static constexpr char const * const name{"addr_encoding"};
  static constexpr char const * const typestr{"int"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_addr_encoding};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_addr_encoding>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = bool;
  static constexpr size_t position{11};
  static constexpr char const * const name{"sig_frame"};
  static constexpr char const * const typestr{"bool"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_sig_frame};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, bool SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_sig_frame>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = SgUnsignedCharList;
  static constexpr size_t position{12};
  static constexpr char const * const name{"instructions"};
  static constexpr char const * const typestr{"SgUnsignedCharList"};
  static constexpr bool traverse{false};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_instructions};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, SgUnsignedCharList SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_instructions>;
};
template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries> {
  using parent = SgAsmElfEHFrameEntryCI;
  using field_type = SgAsmElfEHFrameEntryFDList*;
  static constexpr size_t position{13};
  static constexpr char const * const name{"fd_entries"};
  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryFDList*"};
  static constexpr bool traverse{true};
  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_fd_entries};
  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
  using bind = Desc<SgAsmElfEHFrameEntryCI, SgAsmElfEHFrameEntryFDList* SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_fd_entries>;
};
template <> struct describe_node_t<SgAsmElfEHFrameEntryCI> {
  using node = SgAsmElfEHFrameEntryCI;
  using base = SgAsmExecutableFileFormat;
  static constexpr char const * const name{"AsmElfEHFrameEntryCI"};
  static constexpr unsigned long variant{151};
  static constexpr bool concrete{true};
  using subclasses_t = mp::List<>;
  using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version>, describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor>, describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg>, describe_field_t<SgAsmElfEHFrameEntryCI,rose_addr_t,&SgAsmElfEHFrameEntryCI::p_prh_addr>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame>, describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions>, describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries>>;
};
template <> struct node_from_variant_t<151> { using type = SgAsmElfEHFrameEntryCI; };

// Class: AsmElfEHFrameEntryCIList
template <> struct describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries> {
  using parent = SgAsmElfEHFrameEntryCIList;
  using field_type = SgAsmElfEHFrameEntryCIPtrList;
  static constexpr size_t position{0};
  static constexpr char const * const name{"entries"};