ROSE_HTML_Reference/generated_8h_source.html

#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,SgStatementPtrList,&SgAdaPackageBody::p_statements> {

  using parent = SgAdaPackageBody;

  using field_type = SgStatementPtrList;

  static constexpr size_t position{0};

  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,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_field_t<SgAdaPackageBodyDecl,SgAdaPackageSpecDecl*,&SgAdaPackageBodyDecl::p_spec> {

  using parent = SgAdaPackageBodyDecl;

  using field_type = SgAdaPackageSpecDecl*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"spec"};

  static constexpr char const * const typestr{"SgAdaPackageSpecDecl*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_spec};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAdaPackageBodyDecl, SgAdaPackageSpecDecl* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_spec>;

};


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>, describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageSpecDecl*,&SgAdaPackageBodyDecl::p_spec>>;

};


template <> struct node_from_variant_t<13> { using type = SgAdaPackageBodyDecl; };


// Class: AdaPackageSpec


template <> struct describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate> {

  using parent = SgAdaPackageSpec;

  using field_type = bool;

  static constexpr size_t position{0};

  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{1};

  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,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_field_t<SgAdaPackageSpecDecl,SgAdaPackageBodyDecl*,&SgAdaPackageSpecDecl::p_body> {

  using parent = SgAdaPackageSpecDecl;

  using field_type = SgAdaPackageBodyDecl*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgAdaPackageBodyDecl*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAdaPackageSpecDecl, SgAdaPackageBodyDecl* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_body>;

};


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>, describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageBodyDecl*,&SgAdaPackageSpecDecl::p_body>>;

};


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,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations> {

  using parent = SgAdaTaskSpec;

  using field_type = SgDeclarationStatementPtrList;

  static constexpr size_t position{1};

  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{2};

  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,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,SgAdaTaskSymbol*,&SgAdaTaskRefExp::p_symbol> {

  using parent = SgAdaTaskRefExp;

  using field_type = SgAdaTaskSymbol*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"symbol"};

  static constexpr char const * const typestr{"SgAdaTaskSymbol*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAdaTaskRefExp::p_symbol};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAdaTaskRefExp, SgAdaTaskSymbol* SgAdaTaskRefExp::*, &SgAdaTaskRefExp::p_symbol>;

};


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,SgAdaTaskSymbol*,&SgAdaTaskRefExp::p_symbol>>;

};


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_field_t<SgAdaTaskTypeDecl,SgScopeStatement*,&SgAdaTaskTypeDecl::p_scope> {

  using parent = SgAdaTaskTypeDecl;

  using field_type = SgScopeStatement*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"scope"};

  static constexpr char const * const typestr{"SgScopeStatement*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_scope};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAdaTaskTypeDecl, SgScopeStatement* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_scope>;

};


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>, describe_field_t<SgAdaTaskTypeDecl,SgScopeStatement*,&SgAdaTaskTypeDecl::p_scope>>;

};


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, SgAsmBinaryAsr, SgAsmBinaryConcat, SgAsmBinaryDivide, SgAsmBinaryLsl, SgAsmBinaryLsr, SgAsmBinaryMod, SgAsmBinaryMsl, SgAsmBinaryMultiply, SgAsmBinaryPostupdate, SgAsmBinaryPreupdate, SgAsmBinaryRor, SgAsmBinarySubtract>;

  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::BinaryAnalysis::Address,&SgAsmBlock::p_id> {

  using parent = SgAsmBlock;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{0};

  static constexpr char const * const name{"id"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  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::BinaryAnalysis::Address 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_successorsComplete> {

  using parent = SgAsmBlock;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"successorsComplete"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBlock::p_successorsComplete};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBlock, bool SgAsmBlock::*, &SgAsmBlock::p_successorsComplete>;

};


template <> struct describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediateDominator> {

  using parent = SgAsmBlock;

  using field_type = SgAsmBlock*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"immediateDominator"};

  static constexpr char const * const typestr{"SgAsmBlock*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBlock::p_immediateDominator};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBlock, SgAsmBlock* SgAsmBlock::*, &SgAsmBlock::p_immediateDominator>;

};


template <> struct describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cachedVertex> {

  using parent = SgAsmBlock;

  using field_type = size_t;

  static constexpr size_t position{6};

  static constexpr char const * const name{"cachedVertex"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBlock::p_cachedVertex};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBlock, size_t SgAsmBlock::*, &SgAsmBlock::p_cachedVertex>;

};


template <> struct describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_codeLikelihood> {

  using parent = SgAsmBlock;

  using field_type = double;

  static constexpr size_t position{7};

  static constexpr char const * const name{"codeLikelihood"};

  static constexpr char const * const typestr{"double"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBlock::p_codeLikelihood};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBlock, double SgAsmBlock::*, &SgAsmBlock::p_codeLikelihood>;

};


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::BinaryAnalysis::Address,&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_successorsComplete>, describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediateDominator>, describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cachedVertex>, describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_codeLikelihood>, 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::BinaryAnalysis::Address,&SgAsmCoffSymbol::p_st_name_offset> {

  using parent = SgAsmCoffSymbol;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{1};

  static constexpr char const * const name{"st_name_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  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::BinaryAnalysis::Address 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_auxiliaryData> {

  using parent = SgAsmCoffSymbol;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{6};

  static constexpr char const * const name{"auxiliaryData"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_auxiliaryData};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmCoffSymbol, SgUnsignedCharList SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_auxiliaryData>;

};


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::BinaryAnalysis::Address,&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_auxiliaryData>>;

};


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_bitFlags> {

  using parent = SgAsmControlFlagsExpression;

  using field_type = unsigned long;

  static constexpr size_t position{0};

  static constexpr char const * const name{"bitFlags"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmControlFlagsExpression::p_bitFlags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmControlFlagsExpression, unsigned long SgAsmControlFlagsExpression::*, &SgAsmControlFlagsExpression::p_bitFlags>;

};


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_bitFlags>>;

};


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<SgAsmFloatValueExpression, SgAsmIntegerValueExpression>;

  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::BinaryAnalysis::Address,&SgAsmDOSExtendedHeader::p_e_lfanew> {

  using parent = SgAsmDOSExtendedHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{8};

  static constexpr char const * const name{"e_lfanew"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  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::BinaryAnalysis::Address 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::BinaryAnalysis::Address,&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::BinaryAnalysis::Address,&SgAsmDOSFileHeader::p_e_relocs_offset> {

  using parent = SgAsmDOSFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{12};

  static constexpr char const * const name{"e_relocs_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  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::BinaryAnalysis::Address 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{false};

  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::BinaryAnalysis::Address,&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<SgAsmFunction, SgAsmSynthesizedDataStructureDeclaration, 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_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<SgAsmDwarfAccessDeclaration, SgAsmDwarfArrayType, SgAsmDwarfBaseType, SgAsmDwarfCatchBlock, SgAsmDwarfClassTemplate, SgAsmDwarfClassType, SgAsmDwarfCommonBlock, SgAsmDwarfCommonInclusion, SgAsmDwarfCompilationUnit, SgAsmDwarfCondition, SgAsmDwarfConstant, SgAsmDwarfConstType, SgAsmDwarfDwarfProcedure, SgAsmDwarfEntryPoint, SgAsmDwarfEnumerationType, SgAsmDwarfEnumerator, SgAsmDwarfFileType, SgAsmDwarfFormalParameter, SgAsmDwarfFormatLabel, SgAsmDwarfFriend, SgAsmDwarfFunctionTemplate, SgAsmDwarfImportedDeclaration, SgAsmDwarfImportedModule, SgAsmDwarfImportedUnit, SgAsmDwarfInheritance, SgAsmDwarfInlinedSubroutine, SgAsmDwarfInterfaceType, SgAsmDwarfLabel, SgAsmDwarfLexicalBlock, SgAsmDwarfMember, SgAsmDwarfModule, SgAsmDwarfMutableType, SgAsmDwarfNamelist, SgAsmDwarfNamelistItem, SgAsmDwarfNamespace, SgAsmDwarfPackedType, SgAsmDwarfPartialUnit, SgAsmDwarfPointerType, SgAsmDwarfPtrToMemberType, SgAsmDwarfReferenceType, SgAsmDwarfRestrictType, SgAsmDwarfSetType, SgAsmDwarfSharedType, SgAsmDwarfStringType, SgAsmDwarfStructureType, SgAsmDwarfSubprogram, SgAsmDwarfSubrangeType, SgAsmDwarfSubroutineType, SgAsmDwarfTemplateTypeParameter, SgAsmDwarfTemplateValueParameter, SgAsmDwarfThrownType, SgAsmDwarfTryBlock, SgAsmDwarfTypedef, SgAsmDwarfUnionType, SgAsmDwarfUnknownConstruct, SgAsmDwarfUnspecifiedParameters, SgAsmDwarfUnspecifiedType, SgAsmDwarfUpcRelaxedType, SgAsmDwarfUpcSharedType, SgAsmDwarfUpcStrictType, SgAsmDwarfVariable, SgAsmDwarfVariant, SgAsmDwarfVariantPart, SgAsmDwarfVolatileType, SgAsmDwarfWithStmt>;

  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>>;

};


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<SgAsmDwarfCompilationUnitList, SgAsmDwarfConstruct, SgAsmDwarfConstructList, SgAsmDwarfLine, SgAsmDwarfLineList, SgAsmDwarfMacro, SgAsmDwarfMacroList>;

  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::BinaryAnalysis::RelativeVirtualAddress,&SgAsmElfDynamicEntry::p_d_val> {

  using parent = SgAsmElfDynamicEntry;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{1};

  static constexpr char const * const name{"d_val"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  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::BinaryAnalysis::RelativeVirtualAddress 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::BinaryAnalysis::RelativeVirtualAddress,&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::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryCI::p_prh_addr> {

  using parent = SgAsmElfEHFrameEntryCI;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{9};

  static constexpr char const * const name{"prh_addr"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  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::BinaryAnalysis::Address 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::BinaryAnalysis::Address,&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"};

  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryCIPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCIList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryCIList, SgAsmElfEHFrameEntryCIPtrList SgAsmElfEHFrameEntryCIList::*, &SgAsmElfEHFrameEntryCIList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfEHFrameEntryCIList> {

  using node = SgAsmElfEHFrameEntryCIList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfEHFrameEntryCIList"};

  static constexpr unsigned long variant{152};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries>>;

};


template <> struct node_from_variant_t<152> { using type = SgAsmElfEHFrameEntryCIList; };


// Class: AsmElfEHFrameEntryFD


template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmElfEHFrameEntryFD::p_begin_rva> {

  using parent = SgAsmElfEHFrameEntryFD;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{0};

  static constexpr char const * const name{"begin_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_begin_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryFD, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_begin_rva>;

};


template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryFD::p_size> {

  using parent = SgAsmElfEHFrameEntryFD;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{1};

  static constexpr char const * const name{"size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryFD, Rose::BinaryAnalysis::Address SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_size>;

};


template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_augmentation_data> {

  using parent = SgAsmElfEHFrameEntryFD;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{2};

  static constexpr char const * const name{"augmentation_data"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_augmentation_data};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryFD, SgUnsignedCharList SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_augmentation_data>;

};


template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_instructions> {

  using parent = SgAsmElfEHFrameEntryFD;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{3};

  static constexpr char const * const name{"instructions"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_instructions};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryFD, SgUnsignedCharList SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_instructions>;

};


template <> struct describe_node_t<SgAsmElfEHFrameEntryFD> {

  using node = SgAsmElfEHFrameEntryFD;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfEHFrameEntryFD"};

  static constexpr unsigned long variant{153};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmElfEHFrameEntryFD::p_begin_rva>, describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryFD::p_size>, describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_augmentation_data>, describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_instructions>>;

};


template <> struct node_from_variant_t<153> { using type = SgAsmElfEHFrameEntryFD; };


// Class: AsmElfEHFrameEntryFDList


template <> struct describe_field_t<SgAsmElfEHFrameEntryFDList,SgAsmElfEHFrameEntryFDPtrList,&SgAsmElfEHFrameEntryFDList::p_entries> {

  using parent = SgAsmElfEHFrameEntryFDList;

  using field_type = SgAsmElfEHFrameEntryFDPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryFDPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFDList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameEntryFDList, SgAsmElfEHFrameEntryFDPtrList SgAsmElfEHFrameEntryFDList::*, &SgAsmElfEHFrameEntryFDList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfEHFrameEntryFDList> {

  using node = SgAsmElfEHFrameEntryFDList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfEHFrameEntryFDList"};

  static constexpr unsigned long variant{154};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryFDList,SgAsmElfEHFrameEntryFDPtrList,&SgAsmElfEHFrameEntryFDList::p_entries>>;

};


template <> struct node_from_variant_t<154> { using type = SgAsmElfEHFrameEntryFDList; };


// Class: AsmElfEHFrameSection


template <> struct describe_field_t<SgAsmElfEHFrameSection,SgAsmElfEHFrameEntryCIList*,&SgAsmElfEHFrameSection::p_ci_entries> {

  using parent = SgAsmElfEHFrameSection;

  using field_type = SgAsmElfEHFrameEntryCIList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"ci_entries"};

  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryCIList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfEHFrameSection::p_ci_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfEHFrameSection, SgAsmElfEHFrameEntryCIList* SgAsmElfEHFrameSection::*, &SgAsmElfEHFrameSection::p_ci_entries>;

};


template <> struct describe_node_t<SgAsmElfEHFrameSection> {

  using node = SgAsmElfEHFrameSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfEHFrameSection"};

  static constexpr unsigned long variant{155};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameSection,SgAsmElfEHFrameEntryCIList*,&SgAsmElfEHFrameSection::p_ci_entries>>;

};


template <> struct node_from_variant_t<155> { using type = SgAsmElfEHFrameSection; };


// Class: AsmElfFileHeader


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_class> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned char;

  static constexpr size_t position{0};

  static constexpr char const * const name{"e_ident_file_class"};

  static constexpr char const * const typestr{"unsigned char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_file_class};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_file_class>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_data_encoding> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned char;

  static constexpr size_t position{1};

  static constexpr char const * const name{"e_ident_data_encoding"};

  static constexpr char const * const typestr{"unsigned char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_data_encoding};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_data_encoding>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_version> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned char;

  static constexpr size_t position{2};

  static constexpr char const * const name{"e_ident_file_version"};

  static constexpr char const * const typestr{"unsigned char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_file_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_file_version>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,SgUnsignedCharList,&SgAsmElfFileHeader::p_e_ident_padding> {

  using parent = SgAsmElfFileHeader;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{3};

  static constexpr char const * const name{"e_ident_padding"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_padding};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, SgUnsignedCharList SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_padding>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_type> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{4};

  static constexpr char const * const name{"e_type"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_type>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_machine> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{5};

  static constexpr char const * const name{"e_machine"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_machine};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_machine>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_flags> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{6};

  static constexpr char const * const name{"e_flags"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_flags>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_ehsize> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{7};

  static constexpr char const * const name{"e_ehsize"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ehsize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ehsize>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_phextrasz> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{8};

  static constexpr char const * const name{"phextrasz"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_phextrasz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_phextrasz>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_phnum> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{9};

  static constexpr char const * const name{"e_phnum"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_phnum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_phnum>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_shextrasz> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{10};

  static constexpr char const * const name{"shextrasz"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_shextrasz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_shextrasz>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shnum> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{11};

  static constexpr char const * const name{"e_shnum"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_shnum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_shnum>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shstrndx> {

  using parent = SgAsmElfFileHeader;

  using field_type = unsigned long;

  static constexpr size_t position{12};

  static constexpr char const * const name{"e_shstrndx"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_shstrndx};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_shstrndx>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,SgAsmElfSectionTable*,&SgAsmElfFileHeader::p_sectionTable> {

  using parent = SgAsmElfFileHeader;

  using field_type = SgAsmElfSectionTable*;

  static constexpr size_t position{13};

  static constexpr char const * const name{"sectionTable"};

  static constexpr char const * const typestr{"SgAsmElfSectionTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_sectionTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, SgAsmElfSectionTable* SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_sectionTable>;

};


template <> struct describe_field_t<SgAsmElfFileHeader,SgAsmElfSegmentTable*,&SgAsmElfFileHeader::p_segmentTable> {

  using parent = SgAsmElfFileHeader;

  using field_type = SgAsmElfSegmentTable*;

  static constexpr size_t position{14};

  static constexpr char const * const name{"segmentTable"};

  static constexpr char const * const typestr{"SgAsmElfSegmentTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_segmentTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfFileHeader, SgAsmElfSegmentTable* SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_segmentTable>;

};


template <> struct describe_node_t<SgAsmElfFileHeader> {

  using node = SgAsmElfFileHeader;

  using base = SgAsmGenericHeader;

  static constexpr char const * const name{"AsmElfFileHeader"};

  static constexpr unsigned long variant{156};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_class>, describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_data_encoding>, describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_version>, describe_field_t<SgAsmElfFileHeader,SgUnsignedCharList,&SgAsmElfFileHeader::p_e_ident_padding>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_type>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_machine>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_flags>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_ehsize>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_phextrasz>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_phnum>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_shextrasz>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shnum>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shstrndx>, describe_field_t<SgAsmElfFileHeader,SgAsmElfSectionTable*,&SgAsmElfFileHeader::p_sectionTable>, describe_field_t<SgAsmElfFileHeader,SgAsmElfSegmentTable*,&SgAsmElfFileHeader::p_segmentTable>>;

};


template <> struct node_from_variant_t<156> { using type = SgAsmElfFileHeader; };


// Class: AsmElfNoteEntry


template <> struct describe_field_t<SgAsmElfNoteEntry,unsigned,&SgAsmElfNoteEntry::p_type> {

  using parent = SgAsmElfNoteEntry;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfNoteEntry, unsigned SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_type>;

};


template <> struct describe_field_t<SgAsmElfNoteEntry,SgAsmGenericString*,&SgAsmElfNoteEntry::p_name> {

  using parent = SgAsmElfNoteEntry;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfNoteEntry, SgAsmGenericString* SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_name>;

};


template <> struct describe_field_t<SgAsmElfNoteEntry,SgUnsignedCharList,&SgAsmElfNoteEntry::p_payload> {

  using parent = SgAsmElfNoteEntry;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{2};

  static constexpr char const * const name{"payload"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_payload};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfNoteEntry, SgUnsignedCharList SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_payload>;

};


template <> struct describe_node_t<SgAsmElfNoteEntry> {

  using node = SgAsmElfNoteEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfNoteEntry"};

  static constexpr unsigned long variant{157};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfNoteEntry,unsigned,&SgAsmElfNoteEntry::p_type>, describe_field_t<SgAsmElfNoteEntry,SgAsmGenericString*,&SgAsmElfNoteEntry::p_name>, describe_field_t<SgAsmElfNoteEntry,SgUnsignedCharList,&SgAsmElfNoteEntry::p_payload>>;

};


template <> struct node_from_variant_t<157> { using type = SgAsmElfNoteEntry; };


// Class: AsmElfNoteEntryList


template <> struct describe_field_t<SgAsmElfNoteEntryList,SgAsmElfNoteEntryPtrList,&SgAsmElfNoteEntryList::p_entries> {

  using parent = SgAsmElfNoteEntryList;

  using field_type = SgAsmElfNoteEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfNoteEntryPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfNoteEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfNoteEntryList, SgAsmElfNoteEntryPtrList SgAsmElfNoteEntryList::*, &SgAsmElfNoteEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfNoteEntryList> {

  using node = SgAsmElfNoteEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfNoteEntryList"};

  static constexpr unsigned long variant{158};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfNoteEntryList,SgAsmElfNoteEntryPtrList,&SgAsmElfNoteEntryList::p_entries>>;

};


template <> struct node_from_variant_t<158> { using type = SgAsmElfNoteEntryList; };


// Class: AsmElfNoteSection


template <> struct describe_field_t<SgAsmElfNoteSection,SgAsmElfNoteEntryList*,&SgAsmElfNoteSection::p_entries> {

  using parent = SgAsmElfNoteSection;

  using field_type = SgAsmElfNoteEntryList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfNoteEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfNoteSection::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfNoteSection, SgAsmElfNoteEntryList* SgAsmElfNoteSection::*, &SgAsmElfNoteSection::p_entries>;

};


template <> struct describe_node_t<SgAsmElfNoteSection> {

  using node = SgAsmElfNoteSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfNoteSection"};

  static constexpr unsigned long variant{159};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfNoteSection,SgAsmElfNoteEntryList*,&SgAsmElfNoteSection::p_entries>>;

};


template <> struct node_from_variant_t<159> { using type = SgAsmElfNoteSection; };


// Class: AsmElfRelocEntry


template <> struct describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_offset> {

  using parent = SgAsmElfRelocEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{0};

  static constexpr char const * const name{"r_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_r_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntry, Rose::BinaryAnalysis::Address SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_r_offset>;

};


template <> struct describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_addend> {

  using parent = SgAsmElfRelocEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{1};

  static constexpr char const * const name{"r_addend"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_r_addend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntry, Rose::BinaryAnalysis::Address SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_r_addend>;

};


template <> struct describe_field_t<SgAsmElfRelocEntry,unsigned long,&SgAsmElfRelocEntry::p_sym> {

  using parent = SgAsmElfRelocEntry;

  using field_type = unsigned long;

  static constexpr size_t position{2};

  static constexpr char const * const name{"sym"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_sym};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntry, unsigned long SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_sym>;

};


template <> struct describe_field_t<SgAsmElfRelocEntry,SgAsmElfRelocEntry::RelocType,&SgAsmElfRelocEntry::p_type> {

  using parent = SgAsmElfRelocEntry;

  using field_type = SgAsmElfRelocEntry::RelocType;

  static constexpr size_t position{3};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgAsmElfRelocEntry::RelocType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntry, SgAsmElfRelocEntry::RelocType SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_type>;

};


template <> struct describe_field_t<SgAsmElfRelocEntry,SgUnsignedCharList,&SgAsmElfRelocEntry::p_extra> {

  using parent = SgAsmElfRelocEntry;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"extra"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_extra};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntry, SgUnsignedCharList SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_extra>;

};


template <> struct describe_node_t<SgAsmElfRelocEntry> {

  using node = SgAsmElfRelocEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfRelocEntry"};

  static constexpr unsigned long variant{160};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_offset>, describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_addend>, describe_field_t<SgAsmElfRelocEntry,unsigned long,&SgAsmElfRelocEntry::p_sym>, describe_field_t<SgAsmElfRelocEntry,SgAsmElfRelocEntry::RelocType,&SgAsmElfRelocEntry::p_type>, describe_field_t<SgAsmElfRelocEntry,SgUnsignedCharList,&SgAsmElfRelocEntry::p_extra>>;

};


template <> struct node_from_variant_t<160> { using type = SgAsmElfRelocEntry; };


// Class: AsmElfRelocEntryList


template <> struct describe_field_t<SgAsmElfRelocEntryList,SgAsmElfRelocEntryPtrList,&SgAsmElfRelocEntryList::p_entries> {

  using parent = SgAsmElfRelocEntryList;

  using field_type = SgAsmElfRelocEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfRelocEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfRelocEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocEntryList, SgAsmElfRelocEntryPtrList SgAsmElfRelocEntryList::*, &SgAsmElfRelocEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfRelocEntryList> {

  using node = SgAsmElfRelocEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfRelocEntryList"};

  static constexpr unsigned long variant{161};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfRelocEntryList,SgAsmElfRelocEntryPtrList,&SgAsmElfRelocEntryList::p_entries>>;

};


template <> struct node_from_variant_t<161> { using type = SgAsmElfRelocEntryList; };


// Class: AsmElfRelocSection


template <> struct describe_field_t<SgAsmElfRelocSection,bool,&SgAsmElfRelocSection::p_usesAddend> {

  using parent = SgAsmElfRelocSection;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"usesAddend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_usesAddend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocSection, bool SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_usesAddend>;

};


template <> struct describe_field_t<SgAsmElfRelocSection,SgAsmElfSection*,&SgAsmElfRelocSection::p_targetSection> {

  using parent = SgAsmElfRelocSection;

  using field_type = SgAsmElfSection*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"targetSection"};

  static constexpr char const * const typestr{"SgAsmElfSection*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_targetSection};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocSection, SgAsmElfSection* SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_targetSection>;

};


template <> struct describe_field_t<SgAsmElfRelocSection,SgAsmElfRelocEntryList*,&SgAsmElfRelocSection::p_entries> {

  using parent = SgAsmElfRelocSection;

  using field_type = SgAsmElfRelocEntryList*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfRelocEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfRelocSection, SgAsmElfRelocEntryList* SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_entries>;

};


template <> struct describe_node_t<SgAsmElfRelocSection> {

  using node = SgAsmElfRelocSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfRelocSection"};

  static constexpr unsigned long variant{162};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfRelocSection,bool,&SgAsmElfRelocSection::p_usesAddend>, describe_field_t<SgAsmElfRelocSection,SgAsmElfSection*,&SgAsmElfRelocSection::p_targetSection>, describe_field_t<SgAsmElfRelocSection,SgAsmElfRelocEntryList*,&SgAsmElfRelocSection::p_entries>>;

};


template <> struct node_from_variant_t<162> { using type = SgAsmElfRelocSection; };


// Class: AsmElfSection


template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSection*,&SgAsmElfSection::p_linkedSection> {

  using parent = SgAsmElfSection;

  using field_type = SgAsmElfSection*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"linkedSection"};

  static constexpr char const * const typestr{"SgAsmElfSection*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSection::p_linkedSection};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSection, SgAsmElfSection* SgAsmElfSection::*, &SgAsmElfSection::p_linkedSection>;

};


template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSectionTableEntry*,&SgAsmElfSection::p_sectionEntry> {

  using parent = SgAsmElfSection;

  using field_type = SgAsmElfSectionTableEntry*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"sectionEntry"};

  static constexpr char const * const typestr{"SgAsmElfSectionTableEntry*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSection::p_sectionEntry};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSection, SgAsmElfSectionTableEntry* SgAsmElfSection::*, &SgAsmElfSection::p_sectionEntry>;

};


template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSegmentTableEntry*,&SgAsmElfSection::p_segmentEntry> {

  using parent = SgAsmElfSection;

  using field_type = SgAsmElfSegmentTableEntry*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"segmentEntry"};

  static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSection::p_segmentEntry};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSection, SgAsmElfSegmentTableEntry* SgAsmElfSection::*, &SgAsmElfSection::p_segmentEntry>;

};


template <> struct describe_node_t<SgAsmElfSection> {

  using node = SgAsmElfSection;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmElfSection"};

  static constexpr unsigned long variant{163};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgAsmElfDynamicSection, SgAsmElfEHFrameSection, SgAsmElfNoteSection, SgAsmElfRelocSection, SgAsmElfStringSection, SgAsmElfSymbolSection, SgAsmElfSymverDefinedSection, SgAsmElfSymverNeededSection, SgAsmElfSymverSection>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSection,SgAsmElfSection*,&SgAsmElfSection::p_linkedSection>, describe_field_t<SgAsmElfSection,SgAsmElfSectionTableEntry*,&SgAsmElfSection::p_sectionEntry>, describe_field_t<SgAsmElfSection,SgAsmElfSegmentTableEntry*,&SgAsmElfSection::p_segmentEntry>>;

};


template <> struct node_from_variant_t<163> { using type = SgAsmElfSection; };


// Class: AsmElfSectionTable


template <> struct describe_node_t<SgAsmElfSectionTable> {

  using node = SgAsmElfSectionTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmElfSectionTable"};

  static constexpr unsigned long variant{164};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<164> { using type = SgAsmElfSectionTable; };


// Class: AsmElfSectionTableEntry


template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned,&SgAsmElfSectionTableEntry::p_sh_name> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"sh_name"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, unsigned SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_name>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,SgAsmElfSectionTableEntry::SectionType,&SgAsmElfSectionTableEntry::p_sh_type> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = SgAsmElfSectionTableEntry::SectionType;

  static constexpr size_t position{1};

  static constexpr char const * const name{"sh_type"};

  static constexpr char const * const typestr{"SgAsmElfSectionTableEntry::SectionType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, SgAsmElfSectionTableEntry::SectionType SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_type>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_link> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = unsigned long;

  static constexpr size_t position{2};

  static constexpr char const * const name{"sh_link"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_link};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, unsigned long SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_link>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_info> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = unsigned long;

  static constexpr size_t position{3};

  static constexpr char const * const name{"sh_info"};

  static constexpr char const * const typestr{"unsigned long"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_info};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, unsigned long SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_info>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,uint64_t,&SgAsmElfSectionTableEntry::p_sh_flags> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = uint64_t;

  static constexpr size_t position{4};

  static constexpr char const * const name{"sh_flags"};

  static constexpr char const * const typestr{"uint64_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, uint64_t SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_flags>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addr> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{5};

  static constexpr char const * const name{"sh_addr"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_addr};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_addr>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_offset> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{6};

  static constexpr char const * const name{"sh_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_offset>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_size> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{7};

  static constexpr char const * const name{"sh_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_size>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addralign> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{8};

  static constexpr char const * const name{"sh_addralign"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_addralign};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_addralign>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_entsize> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{9};

  static constexpr char const * const name{"sh_entsize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_entsize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_entsize>;

};


template <> struct describe_field_t<SgAsmElfSectionTableEntry,SgUnsignedCharList,&SgAsmElfSectionTableEntry::p_extra> {

  using parent = SgAsmElfSectionTableEntry;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{10};

  static constexpr char const * const name{"extra"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_extra};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSectionTableEntry, SgUnsignedCharList SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_extra>;

};


template <> struct describe_node_t<SgAsmElfSectionTableEntry> {

  using node = SgAsmElfSectionTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSectionTableEntry"};

  static constexpr unsigned long variant{165};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSectionTableEntry,unsigned,&SgAsmElfSectionTableEntry::p_sh_name>, describe_field_t<SgAsmElfSectionTableEntry,SgAsmElfSectionTableEntry::SectionType,&SgAsmElfSectionTableEntry::p_sh_type>, describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_link>, describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_info>, describe_field_t<SgAsmElfSectionTableEntry,uint64_t,&SgAsmElfSectionTableEntry::p_sh_flags>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addr>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_offset>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_size>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addralign>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_entsize>, describe_field_t<SgAsmElfSectionTableEntry,SgUnsignedCharList,&SgAsmElfSectionTableEntry::p_extra>>;

};


template <> struct node_from_variant_t<165> { using type = SgAsmElfSectionTableEntry; };


// Class: AsmElfSegmentTable


template <> struct describe_node_t<SgAsmElfSegmentTable> {

  using node = SgAsmElfSegmentTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmElfSegmentTable"};

  static constexpr unsigned long variant{166};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<166> { using type = SgAsmElfSegmentTable; };


// Class: AsmElfSegmentTableEntry


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,size_t,&SgAsmElfSegmentTableEntry::p_index> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"index"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, size_t SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_index>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentType,&SgAsmElfSegmentTableEntry::p_type> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = SgAsmElfSegmentTableEntry::SegmentType;

  static constexpr size_t position{1};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry::SegmentType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntry::SegmentType SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_type>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentFlags,&SgAsmElfSegmentTableEntry::p_flags> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = SgAsmElfSegmentTableEntry::SegmentFlags;

  static constexpr size_t position{2};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry::SegmentFlags"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntry::SegmentFlags SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_flags>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_offset> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_offset>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_vaddr> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"vaddr"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_vaddr};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_vaddr>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_paddr> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{5};

  static constexpr char const * const name{"paddr"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_paddr};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_paddr>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_filesz> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{6};

  static constexpr char const * const name{"filesz"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_filesz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_filesz>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_memsz> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{7};

  static constexpr char const * const name{"memsz"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_memsz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_memsz>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_align> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{8};

  static constexpr char const * const name{"align"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_align};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_align>;

};


template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgUnsignedCharList,&SgAsmElfSegmentTableEntry::p_extra> {

  using parent = SgAsmElfSegmentTableEntry;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{9};

  static constexpr char const * const name{"extra"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_extra};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntry, SgUnsignedCharList SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_extra>;

};


template <> struct describe_node_t<SgAsmElfSegmentTableEntry> {

  using node = SgAsmElfSegmentTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSegmentTableEntry"};

  static constexpr unsigned long variant{167};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSegmentTableEntry,size_t,&SgAsmElfSegmentTableEntry::p_index>, describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentType,&SgAsmElfSegmentTableEntry::p_type>, describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentFlags,&SgAsmElfSegmentTableEntry::p_flags>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_offset>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_vaddr>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_paddr>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_filesz>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_memsz>, describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_align>, describe_field_t<SgAsmElfSegmentTableEntry,SgUnsignedCharList,&SgAsmElfSegmentTableEntry::p_extra>>;

};


template <> struct node_from_variant_t<167> { using type = SgAsmElfSegmentTableEntry; };


// Class: AsmElfSegmentTableEntryList


template <> struct describe_field_t<SgAsmElfSegmentTableEntryList,SgAsmElfSegmentTableEntryPtrList,&SgAsmElfSegmentTableEntryList::p_entries> {

  using parent = SgAsmElfSegmentTableEntryList;

  using field_type = SgAsmElfSegmentTableEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSegmentTableEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSegmentTableEntryList, SgAsmElfSegmentTableEntryPtrList SgAsmElfSegmentTableEntryList::*, &SgAsmElfSegmentTableEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSegmentTableEntryList> {

  using node = SgAsmElfSegmentTableEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSegmentTableEntryList"};

  static constexpr unsigned long variant{168};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSegmentTableEntryList,SgAsmElfSegmentTableEntryPtrList,&SgAsmElfSegmentTableEntryList::p_entries>>;

};


template <> struct node_from_variant_t<168> { using type = SgAsmElfSegmentTableEntryList; };


// Class: AsmElfStringSection


template <> struct describe_field_t<SgAsmElfStringSection,SgAsmElfStrtab*,&SgAsmElfStringSection::p_strtab> {

  using parent = SgAsmElfStringSection;

  using field_type = SgAsmElfStrtab*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"strtab"};

  static constexpr char const * const typestr{"SgAsmElfStrtab*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfStringSection::p_strtab};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfStringSection, SgAsmElfStrtab* SgAsmElfStringSection::*, &SgAsmElfStringSection::p_strtab>;

};


template <> struct describe_node_t<SgAsmElfStringSection> {

  using node = SgAsmElfStringSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfStringSection"};

  static constexpr unsigned long variant{169};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfStringSection,SgAsmElfStrtab*,&SgAsmElfStringSection::p_strtab>>;

};


template <> struct node_from_variant_t<169> { using type = SgAsmElfStringSection; };


// Class: AsmElfStrtab


template <> struct describe_node_t<SgAsmElfStrtab> {

  using node = SgAsmElfStrtab;

  using base = SgAsmGenericStrtab;

  static constexpr char const * const name{"AsmElfStrtab"};

  static constexpr unsigned long variant{170};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<170> { using type = SgAsmElfStrtab; };


// Class: AsmElfSymbol


template <> struct describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_info> {

  using parent = SgAsmElfSymbol;

  using field_type = unsigned char;

  static constexpr size_t position{0};

  static constexpr char const * const name{"st_info"};

  static constexpr char const * const typestr{"unsigned char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_info};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbol, unsigned char SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_info>;

};


template <> struct describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_res1> {

  using parent = SgAsmElfSymbol;

  using field_type = unsigned char;

  static constexpr size_t position{1};

  static constexpr char const * const name{"st_res1"};

  static constexpr char const * const typestr{"unsigned char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_res1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbol, unsigned char SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_res1>;

};


template <> struct describe_field_t<SgAsmElfSymbol,unsigned,&SgAsmElfSymbol::p_st_shndx> {

  using parent = SgAsmElfSymbol;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"st_shndx"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_shndx};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbol, unsigned SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_shndx>;

};


template <> struct describe_field_t<SgAsmElfSymbol,Rose::BinaryAnalysis::Address,&SgAsmElfSymbol::p_st_size> {

  using parent = SgAsmElfSymbol;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"st_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbol, Rose::BinaryAnalysis::Address SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_size>;

};


template <> struct describe_field_t<SgAsmElfSymbol,SgUnsignedCharList,&SgAsmElfSymbol::p_extra> {

  using parent = SgAsmElfSymbol;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"extra"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_extra};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbol, SgUnsignedCharList SgAsmElfSymbol::*, &SgAsmElfSymbol::p_extra>;

};


template <> struct describe_node_t<SgAsmElfSymbol> {

  using node = SgAsmElfSymbol;

  using base = SgAsmGenericSymbol;

  static constexpr char const * const name{"AsmElfSymbol"};

  static constexpr unsigned long variant{171};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_info>, describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_res1>, describe_field_t<SgAsmElfSymbol,unsigned,&SgAsmElfSymbol::p_st_shndx>, describe_field_t<SgAsmElfSymbol,Rose::BinaryAnalysis::Address,&SgAsmElfSymbol::p_st_size>, describe_field_t<SgAsmElfSymbol,SgUnsignedCharList,&SgAsmElfSymbol::p_extra>>;

};


template <> struct node_from_variant_t<171> { using type = SgAsmElfSymbol; };


// Class: AsmElfSymbolList


template <> struct describe_field_t<SgAsmElfSymbolList,SgAsmElfSymbolPtrList,&SgAsmElfSymbolList::p_symbols> {

  using parent = SgAsmElfSymbolList;

  using field_type = SgAsmElfSymbolPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"symbols"};

  static constexpr char const * const typestr{"SgAsmElfSymbolPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymbolList::p_symbols};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbolList, SgAsmElfSymbolPtrList SgAsmElfSymbolList::*, &SgAsmElfSymbolList::p_symbols>;

};


template <> struct describe_node_t<SgAsmElfSymbolList> {

  using node = SgAsmElfSymbolList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymbolList"};

  static constexpr unsigned long variant{172};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymbolList,SgAsmElfSymbolPtrList,&SgAsmElfSymbolList::p_symbols>>;

};


template <> struct node_from_variant_t<172> { using type = SgAsmElfSymbolList; };


// Class: AsmElfSymbolSection


template <> struct describe_field_t<SgAsmElfSymbolSection,bool,&SgAsmElfSymbolSection::p_isDynamic> {

  using parent = SgAsmElfSymbolSection;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"isDynamic"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymbolSection::p_isDynamic};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbolSection, bool SgAsmElfSymbolSection::*, &SgAsmElfSymbolSection::p_isDynamic>;

};


template <> struct describe_field_t<SgAsmElfSymbolSection,SgAsmElfSymbolList*,&SgAsmElfSymbolSection::p_symbols> {

  using parent = SgAsmElfSymbolSection;

  using field_type = SgAsmElfSymbolList*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"symbols"};

  static constexpr char const * const typestr{"SgAsmElfSymbolList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymbolSection::p_symbols};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymbolSection, SgAsmElfSymbolList* SgAsmElfSymbolSection::*, &SgAsmElfSymbolSection::p_symbols>;

};


template <> struct describe_node_t<SgAsmElfSymbolSection> {

  using node = SgAsmElfSymbolSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfSymbolSection"};

  static constexpr unsigned long variant{173};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymbolSection,bool,&SgAsmElfSymbolSection::p_isDynamic>, describe_field_t<SgAsmElfSymbolSection,SgAsmElfSymbolList*,&SgAsmElfSymbolSection::p_symbols>>;

};


template <> struct node_from_variant_t<173> { using type = SgAsmElfSymbolSection; };


// Class: AsmElfSymverDefinedAux


template <> struct describe_field_t<SgAsmElfSymverDefinedAux,SgAsmGenericString*,&SgAsmElfSymverDefinedAux::p_name> {

  using parent = SgAsmElfSymverDefinedAux;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedAux::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedAux, SgAsmGenericString* SgAsmElfSymverDefinedAux::*, &SgAsmElfSymverDefinedAux::p_name>;

};


template <> struct describe_node_t<SgAsmElfSymverDefinedAux> {

  using node = SgAsmElfSymverDefinedAux;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverDefinedAux"};

  static constexpr unsigned long variant{174};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedAux,SgAsmGenericString*,&SgAsmElfSymverDefinedAux::p_name>>;

};


template <> struct node_from_variant_t<174> { using type = SgAsmElfSymverDefinedAux; };


// Class: AsmElfSymverDefinedAuxList


template <> struct describe_field_t<SgAsmElfSymverDefinedAuxList,SgAsmElfSymverDefinedAuxPtrList,&SgAsmElfSymverDefinedAuxList::p_entries> {

  using parent = SgAsmElfSymverDefinedAuxList;

  using field_type = SgAsmElfSymverDefinedAuxPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverDefinedAuxPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedAuxList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedAuxList, SgAsmElfSymverDefinedAuxPtrList SgAsmElfSymverDefinedAuxList::*, &SgAsmElfSymverDefinedAuxList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverDefinedAuxList> {

  using node = SgAsmElfSymverDefinedAuxList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverDefinedAuxList"};

  static constexpr unsigned long variant{175};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedAuxList,SgAsmElfSymverDefinedAuxPtrList,&SgAsmElfSymverDefinedAuxList::p_entries>>;

};


template <> struct node_from_variant_t<175> { using type = SgAsmElfSymverDefinedAuxList; };


// Class: AsmElfSymverDefinedEntry


template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_version> {

  using parent = SgAsmElfSymverDefinedEntry;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"version"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntry, size_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_version>;

};


template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,int,&SgAsmElfSymverDefinedEntry::p_flags> {

  using parent = SgAsmElfSymverDefinedEntry;

  using field_type = int;

  static constexpr size_t position{1};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntry, int SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_flags>;

};


template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_index> {

  using parent = SgAsmElfSymverDefinedEntry;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"index"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntry, size_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_index>;

};


template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,uint32_t,&SgAsmElfSymverDefinedEntry::p_hash> {

  using parent = SgAsmElfSymverDefinedEntry;

  using field_type = uint32_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"hash"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_hash};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntry, uint32_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_hash>;

};


template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,SgAsmElfSymverDefinedAuxList*,&SgAsmElfSymverDefinedEntry::p_entries> {

  using parent = SgAsmElfSymverDefinedEntry;

  using field_type = SgAsmElfSymverDefinedAuxList*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverDefinedAuxList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntry, SgAsmElfSymverDefinedAuxList* SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverDefinedEntry> {

  using node = SgAsmElfSymverDefinedEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverDefinedEntry"};

  static constexpr unsigned long variant{176};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_version>, describe_field_t<SgAsmElfSymverDefinedEntry,int,&SgAsmElfSymverDefinedEntry::p_flags>, describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_index>, describe_field_t<SgAsmElfSymverDefinedEntry,uint32_t,&SgAsmElfSymverDefinedEntry::p_hash>, describe_field_t<SgAsmElfSymverDefinedEntry,SgAsmElfSymverDefinedAuxList*,&SgAsmElfSymverDefinedEntry::p_entries>>;

};


template <> struct node_from_variant_t<176> { using type = SgAsmElfSymverDefinedEntry; };


// Class: AsmElfSymverDefinedEntryList


template <> struct describe_field_t<SgAsmElfSymverDefinedEntryList,SgAsmElfSymverDefinedEntryPtrList,&SgAsmElfSymverDefinedEntryList::p_entries> {

  using parent = SgAsmElfSymverDefinedEntryList;

  using field_type = SgAsmElfSymverDefinedEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverDefinedEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedEntryList, SgAsmElfSymverDefinedEntryPtrList SgAsmElfSymverDefinedEntryList::*, &SgAsmElfSymverDefinedEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverDefinedEntryList> {

  using node = SgAsmElfSymverDefinedEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverDefinedEntryList"};

  static constexpr unsigned long variant{177};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedEntryList,SgAsmElfSymverDefinedEntryPtrList,&SgAsmElfSymverDefinedEntryList::p_entries>>;

};


template <> struct node_from_variant_t<177> { using type = SgAsmElfSymverDefinedEntryList; };


// Class: AsmElfSymverDefinedSection


template <> struct describe_field_t<SgAsmElfSymverDefinedSection,SgAsmElfSymverDefinedEntryList*,&SgAsmElfSymverDefinedSection::p_entries> {

  using parent = SgAsmElfSymverDefinedSection;

  using field_type = SgAsmElfSymverDefinedEntryList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverDefinedEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedSection::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverDefinedSection, SgAsmElfSymverDefinedEntryList* SgAsmElfSymverDefinedSection::*, &SgAsmElfSymverDefinedSection::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverDefinedSection> {

  using node = SgAsmElfSymverDefinedSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfSymverDefinedSection"};

  static constexpr unsigned long variant{178};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedSection,SgAsmElfSymverDefinedEntryList*,&SgAsmElfSymverDefinedSection::p_entries>>;

};


template <> struct node_from_variant_t<178> { using type = SgAsmElfSymverDefinedSection; };


// Class: AsmElfSymverEntry


template <> struct describe_field_t<SgAsmElfSymverEntry,size_t,&SgAsmElfSymverEntry::p_value> {

  using parent = SgAsmElfSymverEntry;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverEntry::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverEntry, size_t SgAsmElfSymverEntry::*, &SgAsmElfSymverEntry::p_value>;

};


template <> struct describe_node_t<SgAsmElfSymverEntry> {

  using node = SgAsmElfSymverEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverEntry"};

  static constexpr unsigned long variant{179};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverEntry,size_t,&SgAsmElfSymverEntry::p_value>>;

};


template <> struct node_from_variant_t<179> { using type = SgAsmElfSymverEntry; };


// Class: AsmElfSymverEntryList


template <> struct describe_field_t<SgAsmElfSymverEntryList,SgAsmElfSymverEntryPtrList,&SgAsmElfSymverEntryList::p_entries> {

  using parent = SgAsmElfSymverEntryList;

  using field_type = SgAsmElfSymverEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverEntryList, SgAsmElfSymverEntryPtrList SgAsmElfSymverEntryList::*, &SgAsmElfSymverEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverEntryList> {

  using node = SgAsmElfSymverEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverEntryList"};

  static constexpr unsigned long variant{180};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverEntryList,SgAsmElfSymverEntryPtrList,&SgAsmElfSymverEntryList::p_entries>>;

};


template <> struct node_from_variant_t<180> { using type = SgAsmElfSymverEntryList; };


// Class: AsmElfSymverNeededAux


template <> struct describe_field_t<SgAsmElfSymverNeededAux,uint32_t,&SgAsmElfSymverNeededAux::p_hash> {

  using parent = SgAsmElfSymverNeededAux;

  using field_type = uint32_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"hash"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_hash};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededAux, uint32_t SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_hash>;

};


template <> struct describe_field_t<SgAsmElfSymverNeededAux,int,&SgAsmElfSymverNeededAux::p_flags> {

  using parent = SgAsmElfSymverNeededAux;

  using field_type = int;

  static constexpr size_t position{1};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededAux, int SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_flags>;

};


template <> struct describe_field_t<SgAsmElfSymverNeededAux,size_t,&SgAsmElfSymverNeededAux::p_other> {

  using parent = SgAsmElfSymverNeededAux;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"other"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_other};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededAux, size_t SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_other>;

};


template <> struct describe_field_t<SgAsmElfSymverNeededAux,SgAsmGenericString*,&SgAsmElfSymverNeededAux::p_name> {

  using parent = SgAsmElfSymverNeededAux;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededAux, SgAsmGenericString* SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_name>;

};


template <> struct describe_node_t<SgAsmElfSymverNeededAux> {

  using node = SgAsmElfSymverNeededAux;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverNeededAux"};

  static constexpr unsigned long variant{181};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededAux,uint32_t,&SgAsmElfSymverNeededAux::p_hash>, describe_field_t<SgAsmElfSymverNeededAux,int,&SgAsmElfSymverNeededAux::p_flags>, describe_field_t<SgAsmElfSymverNeededAux,size_t,&SgAsmElfSymverNeededAux::p_other>, describe_field_t<SgAsmElfSymverNeededAux,SgAsmGenericString*,&SgAsmElfSymverNeededAux::p_name>>;

};


template <> struct node_from_variant_t<181> { using type = SgAsmElfSymverNeededAux; };


// Class: AsmElfSymverNeededAuxList


template <> struct describe_field_t<SgAsmElfSymverNeededAuxList,SgAsmElfSymverNeededAuxPtrList,&SgAsmElfSymverNeededAuxList::p_entries> {

  using parent = SgAsmElfSymverNeededAuxList;

  using field_type = SgAsmElfSymverNeededAuxPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverNeededAuxPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAuxList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededAuxList, SgAsmElfSymverNeededAuxPtrList SgAsmElfSymverNeededAuxList::*, &SgAsmElfSymverNeededAuxList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverNeededAuxList> {

  using node = SgAsmElfSymverNeededAuxList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverNeededAuxList"};

  static constexpr unsigned long variant{182};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededAuxList,SgAsmElfSymverNeededAuxPtrList,&SgAsmElfSymverNeededAuxList::p_entries>>;

};


template <> struct node_from_variant_t<182> { using type = SgAsmElfSymverNeededAuxList; };


// Class: AsmElfSymverNeededEntry


template <> struct describe_field_t<SgAsmElfSymverNeededEntry,size_t,&SgAsmElfSymverNeededEntry::p_version> {

  using parent = SgAsmElfSymverNeededEntry;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"version"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededEntry, size_t SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_version>;

};


template <> struct describe_field_t<SgAsmElfSymverNeededEntry,SgAsmGenericString*,&SgAsmElfSymverNeededEntry::p_fileName> {

  using parent = SgAsmElfSymverNeededEntry;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"fileName"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_fileName};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededEntry, SgAsmGenericString* SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_fileName>;

};


template <> struct describe_field_t<SgAsmElfSymverNeededEntry,SgAsmElfSymverNeededAuxList*,&SgAsmElfSymverNeededEntry::p_entries> {

  using parent = SgAsmElfSymverNeededEntry;

  using field_type = SgAsmElfSymverNeededAuxList*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverNeededAuxList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededEntry, SgAsmElfSymverNeededAuxList* SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverNeededEntry> {

  using node = SgAsmElfSymverNeededEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverNeededEntry"};

  static constexpr unsigned long variant{183};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededEntry,size_t,&SgAsmElfSymverNeededEntry::p_version>, describe_field_t<SgAsmElfSymverNeededEntry,SgAsmGenericString*,&SgAsmElfSymverNeededEntry::p_fileName>, describe_field_t<SgAsmElfSymverNeededEntry,SgAsmElfSymverNeededAuxList*,&SgAsmElfSymverNeededEntry::p_entries>>;

};


template <> struct node_from_variant_t<183> { using type = SgAsmElfSymverNeededEntry; };


// Class: AsmElfSymverNeededEntryList


template <> struct describe_field_t<SgAsmElfSymverNeededEntryList,SgAsmElfSymverNeededEntryPtrList,&SgAsmElfSymverNeededEntryList::p_entries> {

  using parent = SgAsmElfSymverNeededEntryList;

  using field_type = SgAsmElfSymverNeededEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverNeededEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntryList::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededEntryList, SgAsmElfSymverNeededEntryPtrList SgAsmElfSymverNeededEntryList::*, &SgAsmElfSymverNeededEntryList::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverNeededEntryList> {

  using node = SgAsmElfSymverNeededEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmElfSymverNeededEntryList"};

  static constexpr unsigned long variant{184};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededEntryList,SgAsmElfSymverNeededEntryPtrList,&SgAsmElfSymverNeededEntryList::p_entries>>;

};


template <> struct node_from_variant_t<184> { using type = SgAsmElfSymverNeededEntryList; };


// Class: AsmElfSymverNeededSection


template <> struct describe_field_t<SgAsmElfSymverNeededSection,SgAsmElfSymverNeededEntryList*,&SgAsmElfSymverNeededSection::p_entries> {

  using parent = SgAsmElfSymverNeededSection;

  using field_type = SgAsmElfSymverNeededEntryList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverNeededEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverNeededSection::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverNeededSection, SgAsmElfSymverNeededEntryList* SgAsmElfSymverNeededSection::*, &SgAsmElfSymverNeededSection::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverNeededSection> {

  using node = SgAsmElfSymverNeededSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfSymverNeededSection"};

  static constexpr unsigned long variant{185};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededSection,SgAsmElfSymverNeededEntryList*,&SgAsmElfSymverNeededSection::p_entries>>;

};


template <> struct node_from_variant_t<185> { using type = SgAsmElfSymverNeededSection; };


// Class: AsmElfSymverSection


template <> struct describe_field_t<SgAsmElfSymverSection,SgAsmElfSymverEntryList*,&SgAsmElfSymverSection::p_entries> {

  using parent = SgAsmElfSymverSection;

  using field_type = SgAsmElfSymverEntryList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmElfSymverEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmElfSymverSection::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmElfSymverSection, SgAsmElfSymverEntryList* SgAsmElfSymverSection::*, &SgAsmElfSymverSection::p_entries>;

};


template <> struct describe_node_t<SgAsmElfSymverSection> {

  using node = SgAsmElfSymverSection;

  using base = SgAsmElfSection;

  static constexpr char const * const name{"AsmElfSymverSection"};

  static constexpr unsigned long variant{186};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmElfSymverSection,SgAsmElfSymverEntryList*,&SgAsmElfSymverSection::p_entries>>;

};


template <> struct node_from_variant_t<186> { using type = SgAsmElfSymverSection; };


// Class: AsmExecutableFileFormat


template <> struct describe_node_t<SgAsmExecutableFileFormat> {

  using node = SgAsmExecutableFileFormat;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmExecutableFileFormat"};

  static constexpr unsigned long variant{187};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmCoffSymbolList, SgAsmDwarfInformation, SgAsmElfDynamicEntry, SgAsmElfDynamicEntryList, SgAsmElfEHFrameEntryCI, SgAsmElfEHFrameEntryCIList, SgAsmElfEHFrameEntryFD, SgAsmElfEHFrameEntryFDList, SgAsmElfNoteEntry, SgAsmElfNoteEntryList, SgAsmElfRelocEntry, SgAsmElfRelocEntryList, SgAsmElfSectionTableEntry, SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntryList, SgAsmElfSymbolList, SgAsmElfSymverDefinedAux, SgAsmElfSymverDefinedAuxList, SgAsmElfSymverDefinedEntry, SgAsmElfSymverDefinedEntryList, SgAsmElfSymverEntry, SgAsmElfSymverEntryList, SgAsmElfSymverNeededAux, SgAsmElfSymverNeededAuxList, SgAsmElfSymverNeededEntry, SgAsmElfSymverNeededEntryList, SgAsmGenericDLL, SgAsmGenericDLLList, SgAsmGenericFile, SgAsmGenericFormat, SgAsmGenericHeaderList, SgAsmGenericSection, SgAsmGenericSectionList, SgAsmGenericString, SgAsmGenericStrtab, SgAsmGenericSymbol, SgAsmGenericSymbolList, SgAsmLEEntryPoint, SgAsmLEPageTableEntry, SgAsmLESectionTableEntry, SgAsmNEEntryPoint, SgAsmNERelocEntry, SgAsmNESectionTableEntry, SgAsmPEExportDirectory, SgAsmPEExportEntry, SgAsmPEExportEntryList, SgAsmPEImportDirectory, SgAsmPEImportDirectoryList, SgAsmPEImportItem, SgAsmPEImportItemList, SgAsmPERVASizePair, SgAsmPERVASizePairList, SgAsmPESectionTableEntry, SgAsmStringStorage>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<187> { using type = SgAsmExecutableFileFormat; };


// Class: AsmExprListExp


template <> struct describe_field_t<SgAsmExprListExp,SgAsmExpressionPtrList,&SgAsmExprListExp::p_expressions> {

  using parent = SgAsmExprListExp;

  using field_type = SgAsmExpressionPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"expressions"};

  static constexpr char const * const typestr{"SgAsmExpressionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmExprListExp::p_expressions};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmExprListExp, SgAsmExpressionPtrList SgAsmExprListExp::*, &SgAsmExprListExp::p_expressions>;

};


template <> struct describe_node_t<SgAsmExprListExp> {

  using node = SgAsmExprListExp;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmExprListExp"};

  static constexpr unsigned long variant{188};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmExprListExp,SgAsmExpressionPtrList,&SgAsmExprListExp::p_expressions>>;

};


template <> struct node_from_variant_t<188> { using type = SgAsmExprListExp; };


// Class: AsmExpression


template <> struct describe_field_t<SgAsmExpression,SgAsmType*,&SgAsmExpression::p_type> {

  using parent = SgAsmExpression;

  using field_type = SgAsmType*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgAsmType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmExpression::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmExpression, SgAsmType* SgAsmExpression::*, &SgAsmExpression::p_type>;

};


template <> struct describe_field_t<SgAsmExpression,std::string,&SgAsmExpression::p_comment> {

  using parent = SgAsmExpression;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"comment"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmExpression::p_comment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmExpression, std::string SgAsmExpression::*, &SgAsmExpression::p_comment>;

};


template <> struct describe_node_t<SgAsmExpression> {

  using node = SgAsmExpression;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmExpression"};

  static constexpr unsigned long variant{189};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmAarch32Coprocessor, SgAsmBinaryExpression, SgAsmByteOrder, SgAsmCommonSubExpression, SgAsmControlFlagsExpression, SgAsmExprListExp, SgAsmMemoryReferenceExpression, SgAsmRegisterNames, SgAsmRegisterReferenceExpression, SgAsmRiscOperation, SgAsmStackExpression, SgAsmUnaryExpression, SgAsmValueExpression>;

  using fields_t = mp::List<describe_field_t<SgAsmExpression,SgAsmType*,&SgAsmExpression::p_type>, describe_field_t<SgAsmExpression,std::string,&SgAsmExpression::p_comment>>;

};


template <> struct node_from_variant_t<189> { using type = SgAsmExpression; };


// Class: AsmSynthesizedFieldDeclaration


template <> struct describe_field_t<SgAsmSynthesizedFieldDeclaration,std::string,&SgAsmSynthesizedFieldDeclaration::p_name> {

  using parent = SgAsmSynthesizedFieldDeclaration;

  using field_type = std::string;

  static constexpr size_t position{0};

  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{&SgAsmSynthesizedFieldDeclaration::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmSynthesizedFieldDeclaration, std::string SgAsmSynthesizedFieldDeclaration::*, &SgAsmSynthesizedFieldDeclaration::p_name>;

};


template <> struct describe_field_t<SgAsmSynthesizedFieldDeclaration,uint64_t,&SgAsmSynthesizedFieldDeclaration::p_offset> {

  using parent = SgAsmSynthesizedFieldDeclaration;

  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{&SgAsmSynthesizedFieldDeclaration::p_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmSynthesizedFieldDeclaration, uint64_t SgAsmSynthesizedFieldDeclaration::*, &SgAsmSynthesizedFieldDeclaration::p_offset>;

};


template <> struct describe_node_t<SgAsmSynthesizedFieldDeclaration> {

  using node = SgAsmSynthesizedFieldDeclaration;

  using base = SgAsmSynthesizedDeclaration;

  static constexpr char const * const name{"AsmSynthesizedFieldDeclaration"};

  static constexpr unsigned long variant{190};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmSynthesizedFieldDeclaration,std::string,&SgAsmSynthesizedFieldDeclaration::p_name>, describe_field_t<SgAsmSynthesizedFieldDeclaration,uint64_t,&SgAsmSynthesizedFieldDeclaration::p_offset>>;

};


template <> struct node_from_variant_t<190> { using type = SgAsmSynthesizedFieldDeclaration; };


// Class: AsmFloatType


template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandOffset> {

  using parent = SgAsmFloatType;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"significandOffset"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_significandOffset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_significandOffset>;

};


template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandNBits> {

  using parent = SgAsmFloatType;

  using field_type = size_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"significandNBits"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_significandNBits};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_significandNBits>;

};


template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_signBitOffset> {

  using parent = SgAsmFloatType;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"signBitOffset"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_signBitOffset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_signBitOffset>;

};


template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentOffset> {

  using parent = SgAsmFloatType;

  using field_type = size_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"exponentOffset"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentOffset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentOffset>;

};


template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentNBits> {

  using parent = SgAsmFloatType;

  using field_type = size_t;

  static constexpr size_t position{4};

  static constexpr char const * const name{"exponentNBits"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentNBits};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentNBits>;

};


template <> struct describe_field_t<SgAsmFloatType,uint64_t,&SgAsmFloatType::p_exponentBias> {

  using parent = SgAsmFloatType;

  using field_type = uint64_t;

  static constexpr size_t position{5};

  static constexpr char const * const name{"exponentBias"};

  static constexpr char const * const typestr{"uint64_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentBias};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, uint64_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentBias>;

};


template <> struct describe_field_t<SgAsmFloatType,unsigned,&SgAsmFloatType::p_flags> {

  using parent = SgAsmFloatType;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFloatType::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFloatType, unsigned SgAsmFloatType::*, &SgAsmFloatType::p_flags>;

};


template <> struct describe_node_t<SgAsmFloatType> {

  using node = SgAsmFloatType;

  using base = SgAsmScalarType;

  static constexpr char const * const name{"AsmFloatType"};

  static constexpr unsigned long variant{191};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandOffset>, describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandNBits>, describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_signBitOffset>, describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentOffset>, describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentNBits>, describe_field_t<SgAsmFloatType,uint64_t,&SgAsmFloatType::p_exponentBias>, describe_field_t<SgAsmFloatType,unsigned,&SgAsmFloatType::p_flags>>;

};


template <> struct node_from_variant_t<191> { using type = SgAsmFloatType; };


// Class: AsmFloatValueExpression


template <> struct describe_node_t<SgAsmFloatValueExpression> {

  using node = SgAsmFloatValueExpression;

  using base = SgAsmConstantExpression;

  static constexpr char const * const name{"AsmFloatValueExpression"};

  static constexpr unsigned long variant{192};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<192> { using type = SgAsmFloatValueExpression; };


// Class: AsmFunction


template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_name> {

  using parent = SgAsmFunction;

  using field_type = std::string;

  static constexpr size_t position{0};

  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{&SgAsmFunction::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_name>;

};


template <> struct describe_field_t<SgAsmFunction,unsigned,&SgAsmFunction::p_reason> {

  using parent = SgAsmFunction;

  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{&SgAsmFunction::p_reason};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, unsigned SgAsmFunction::*, &SgAsmFunction::p_reason>;

};


template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_reasonComment> {

  using parent = SgAsmFunction;

  using field_type = std::string;

  static constexpr size_t position{2};

  static constexpr char const * const name{"reasonComment"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_reasonComment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_reasonComment>;

};


template <> struct describe_field_t<SgAsmFunction,SgAsmFunction::function_kind_enum,&SgAsmFunction::p_functionKind> {

  using parent = SgAsmFunction;

  using field_type = SgAsmFunction::function_kind_enum;

  static constexpr size_t position{3};

  static constexpr char const * const name{"functionKind"};

  static constexpr char const * const typestr{"SgAsmFunction::function_kind_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_functionKind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, SgAsmFunction::function_kind_enum SgAsmFunction::*, &SgAsmFunction::p_functionKind>;

};


template <> struct describe_field_t<SgAsmFunction,SgAsmFunction::MayReturn,&SgAsmFunction::p_mayReturn> {

  using parent = SgAsmFunction;

  using field_type = SgAsmFunction::MayReturn;

  static constexpr size_t position{4};

  static constexpr char const * const name{"mayReturn"};

  static constexpr char const * const typestr{"SgAsmFunction::MayReturn"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_mayReturn};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, SgAsmFunction::MayReturn SgAsmFunction::*, &SgAsmFunction::p_mayReturn>;

};


template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_nameMd5> {

  using parent = SgAsmFunction;

  using field_type = std::string;

  static constexpr size_t position{5};

  static constexpr char const * const name{"nameMd5"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_nameMd5};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_nameMd5>;

};


template <> struct describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_statementList> {

  using parent = SgAsmFunction;

  using field_type = SgAsmStatementPtrList;

  static constexpr size_t position{6};

  static constexpr char const * const name{"statementList"};

  static constexpr char const * const typestr{"SgAsmStatementPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_statementList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, SgAsmStatementPtrList SgAsmFunction::*, &SgAsmFunction::p_statementList>;

};


template <> struct describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_dest> {

  using parent = SgAsmFunction;

  using field_type = SgAsmStatementPtrList;

  static constexpr size_t position{7};

  static constexpr char const * const name{"dest"};

  static constexpr char const * const typestr{"SgAsmStatementPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_dest};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, SgAsmStatementPtrList SgAsmFunction::*, &SgAsmFunction::p_dest>;

};


template <> struct describe_field_t<SgAsmFunction,Rose::BinaryAnalysis::Address,&SgAsmFunction::p_entryVa> {

  using parent = SgAsmFunction;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{8};

  static constexpr char const * const name{"entryVa"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_entryVa};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, Rose::BinaryAnalysis::Address SgAsmFunction::*, &SgAsmFunction::p_entryVa>;

};


template <> struct describe_field_t<SgAsmFunction,SgSymbolTable*,&SgAsmFunction::p_symbolTable> {

  using parent = SgAsmFunction;

  using field_type = SgSymbolTable*;

  static constexpr size_t position{9};

  static constexpr char const * const name{"symbolTable"};

  static constexpr char const * const typestr{"SgSymbolTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_symbolTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, SgSymbolTable* SgAsmFunction::*, &SgAsmFunction::p_symbolTable>;

};


template <> struct describe_field_t<SgAsmFunction,size_t,&SgAsmFunction::p_cachedVertex> {

  using parent = SgAsmFunction;

  using field_type = size_t;

  static constexpr size_t position{10};

  static constexpr char const * const name{"cachedVertex"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_cachedVertex};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, size_t SgAsmFunction::*, &SgAsmFunction::p_cachedVertex>;

};


template <> struct describe_field_t<SgAsmFunction,int64_t,&SgAsmFunction::p_stackDelta> {

  using parent = SgAsmFunction;

  using field_type = int64_t;

  static constexpr size_t position{11};

  static constexpr char const * const name{"stackDelta"};

  static constexpr char const * const typestr{"int64_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_stackDelta};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, int64_t SgAsmFunction::*, &SgAsmFunction::p_stackDelta>;

};


template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_callingConvention> {

  using parent = SgAsmFunction;

  using field_type = std::string;

  static constexpr size_t position{12};

  static constexpr char const * const name{"callingConvention"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmFunction::p_callingConvention};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_callingConvention>;

};


template <> struct describe_node_t<SgAsmFunction> {

  using node = SgAsmFunction;

  using base = SgAsmSynthesizedDeclaration;

  static constexpr char const * const name{"AsmFunction"};

  static constexpr unsigned long variant{193};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_name>, describe_field_t<SgAsmFunction,unsigned,&SgAsmFunction::p_reason>, describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_reasonComment>, describe_field_t<SgAsmFunction,SgAsmFunction::function_kind_enum,&SgAsmFunction::p_functionKind>, describe_field_t<SgAsmFunction,SgAsmFunction::MayReturn,&SgAsmFunction::p_mayReturn>, describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_nameMd5>, describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_statementList>, describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_dest>, describe_field_t<SgAsmFunction,Rose::BinaryAnalysis::Address,&SgAsmFunction::p_entryVa>, describe_field_t<SgAsmFunction,SgSymbolTable*,&SgAsmFunction::p_symbolTable>, describe_field_t<SgAsmFunction,size_t,&SgAsmFunction::p_cachedVertex>, describe_field_t<SgAsmFunction,int64_t,&SgAsmFunction::p_stackDelta>, describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_callingConvention>>;

};


template <> struct node_from_variant_t<193> { using type = SgAsmFunction; };


// Class: AsmGenericDLL


template <> struct describe_field_t<SgAsmGenericDLL,SgAsmGenericString*,&SgAsmGenericDLL::p_name> {

  using parent = SgAsmGenericDLL;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericDLL::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericDLL, SgAsmGenericString* SgAsmGenericDLL::*, &SgAsmGenericDLL::p_name>;

};


template <> struct describe_field_t<SgAsmGenericDLL,SgStringList,&SgAsmGenericDLL::p_symbols> {

  using parent = SgAsmGenericDLL;

  using field_type = SgStringList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"symbols"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericDLL::p_symbols};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericDLL, SgStringList SgAsmGenericDLL::*, &SgAsmGenericDLL::p_symbols>;

};


template <> struct describe_node_t<SgAsmGenericDLL> {

  using node = SgAsmGenericDLL;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericDLL"};

  static constexpr unsigned long variant{194};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericDLL,SgAsmGenericString*,&SgAsmGenericDLL::p_name>, describe_field_t<SgAsmGenericDLL,SgStringList,&SgAsmGenericDLL::p_symbols>>;

};


template <> struct node_from_variant_t<194> { using type = SgAsmGenericDLL; };


// Class: AsmGenericDLLList


template <> struct describe_field_t<SgAsmGenericDLLList,SgAsmGenericDLLPtrList,&SgAsmGenericDLLList::p_dlls> {

  using parent = SgAsmGenericDLLList;

  using field_type = SgAsmGenericDLLPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"dlls"};

  static constexpr char const * const typestr{"SgAsmGenericDLLPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericDLLList::p_dlls};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericDLLList, SgAsmGenericDLLPtrList SgAsmGenericDLLList::*, &SgAsmGenericDLLList::p_dlls>;

};


template <> struct describe_node_t<SgAsmGenericDLLList> {

  using node = SgAsmGenericDLLList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericDLLList"};

  static constexpr unsigned long variant{195};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericDLLList,SgAsmGenericDLLPtrList,&SgAsmGenericDLLList::p_dlls>>;

};


template <> struct node_from_variant_t<195> { using type = SgAsmGenericDLLList; };


// Class: AsmGenericFile


template <> struct describe_field_t<SgAsmGenericFile,SgAsmDwarfCompilationUnitList*,&SgAsmGenericFile::p_dwarfInfo> {

  using parent = SgAsmGenericFile;

  using field_type = SgAsmDwarfCompilationUnitList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"dwarfInfo"};

  static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_dwarfInfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, SgAsmDwarfCompilationUnitList* SgAsmGenericFile::*, &SgAsmGenericFile::p_dwarfInfo>;

};


template <> struct describe_field_t<SgAsmGenericFile,std::string,&SgAsmGenericFile::p_name> {

  using parent = SgAsmGenericFile;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgAsmGenericFile::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, std::string SgAsmGenericFile::*, &SgAsmGenericFile::p_name>;

};


template <> struct describe_field_t<SgAsmGenericFile,int,&SgAsmGenericFile::p_fd> {

  using parent = SgAsmGenericFile;

  using field_type = int;

  static constexpr size_t position{2};

  static constexpr char const * const name{"fd"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_fd};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, int SgAsmGenericFile::*, &SgAsmGenericFile::p_fd>;

};


template <> struct describe_field_t<SgAsmGenericFile,struct stat,&SgAsmGenericFile::p_sb> {

  using parent = SgAsmGenericFile;

  using field_type = struct stat;

  static constexpr size_t position{3};

  static constexpr char const * const name{"sb"};

  static constexpr char const * const typestr{"struct stat"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_sb};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, struct stat SgAsmGenericFile::*, &SgAsmGenericFile::p_sb>;

};


template <> struct describe_field_t<SgAsmGenericFile,SgFileContentList,&SgAsmGenericFile::p_data> {

  using parent = SgAsmGenericFile;

  using field_type = SgFileContentList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"data"};

  static constexpr char const * const typestr{"SgFileContentList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_data};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, SgFileContentList SgAsmGenericFile::*, &SgAsmGenericFile::p_data>;

};


template <> struct describe_field_t<SgAsmGenericFile,SgAsmGenericHeaderList*,&SgAsmGenericFile::p_headers> {

  using parent = SgAsmGenericFile;

  using field_type = SgAsmGenericHeaderList*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"headers"};

  static constexpr char const * const typestr{"SgAsmGenericHeaderList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_headers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, SgAsmGenericHeaderList* SgAsmGenericFile::*, &SgAsmGenericFile::p_headers>;

};


template <> struct describe_field_t<SgAsmGenericFile,SgAsmGenericSectionList*,&SgAsmGenericFile::p_holes> {

  using parent = SgAsmGenericFile;

  using field_type = SgAsmGenericSectionList*;

  static constexpr size_t position{6};

  static constexpr char const * const name{"holes"};

  static constexpr char const * const typestr{"SgAsmGenericSectionList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_holes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, SgAsmGenericSectionList* SgAsmGenericFile::*, &SgAsmGenericFile::p_holes>;

};


template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_truncateZeros> {

  using parent = SgAsmGenericFile;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"truncateZeros"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_truncateZeros};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_truncateZeros>;

};


template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_trackingReferences> {

  using parent = SgAsmGenericFile;

  using field_type = bool;

  static constexpr size_t position{8};

  static constexpr char const * const name{"trackingReferences"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_trackingReferences};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_trackingReferences>;

};


template <> struct describe_field_t<SgAsmGenericFile,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericFile::p_referencedExtents> {

  using parent = SgAsmGenericFile;

  using field_type = Rose::BinaryAnalysis::AddressIntervalSet;

  static constexpr size_t position{9};

  static constexpr char const * const name{"referencedExtents"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::AddressIntervalSet"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_referencedExtents};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, Rose::BinaryAnalysis::AddressIntervalSet SgAsmGenericFile::*, &SgAsmGenericFile::p_referencedExtents>;

};


template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_neuter> {

  using parent = SgAsmGenericFile;

  using field_type = bool;

  static constexpr size_t position{10};

  static constexpr char const * const name{"neuter"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFile::p_neuter};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_neuter>;

};


template <> struct describe_node_t<SgAsmGenericFile> {

  using node = SgAsmGenericFile;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericFile"};

  static constexpr unsigned long variant{196};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericFile,SgAsmDwarfCompilationUnitList*,&SgAsmGenericFile::p_dwarfInfo>, describe_field_t<SgAsmGenericFile,std::string,&SgAsmGenericFile::p_name>, describe_field_t<SgAsmGenericFile,int,&SgAsmGenericFile::p_fd>, describe_field_t<SgAsmGenericFile,struct stat,&SgAsmGenericFile::p_sb>, describe_field_t<SgAsmGenericFile,SgFileContentList,&SgAsmGenericFile::p_data>, describe_field_t<SgAsmGenericFile,SgAsmGenericHeaderList*,&SgAsmGenericFile::p_headers>, describe_field_t<SgAsmGenericFile,SgAsmGenericSectionList*,&SgAsmGenericFile::p_holes>, describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_truncateZeros>, describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_trackingReferences>, describe_field_t<SgAsmGenericFile,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericFile::p_referencedExtents>, describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_neuter>>;

};


template <> struct node_from_variant_t<196> { using type = SgAsmGenericFile; };


// Class: AsmGenericFileList


template <> struct describe_field_t<SgAsmGenericFileList,SgAsmGenericFilePtrList,&SgAsmGenericFileList::p_files> {

  using parent = SgAsmGenericFileList;

  using field_type = SgAsmGenericFilePtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"files"};

  static constexpr char const * const typestr{"SgAsmGenericFilePtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericFileList::p_files};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFileList, SgAsmGenericFilePtrList SgAsmGenericFileList::*, &SgAsmGenericFileList::p_files>;

};


template <> struct describe_node_t<SgAsmGenericFileList> {

  using node = SgAsmGenericFileList;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmGenericFileList"};

  static constexpr unsigned long variant{197};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericFileList,SgAsmGenericFilePtrList,&SgAsmGenericFileList::p_files>>;

};


template <> struct node_from_variant_t<197> { using type = SgAsmGenericFileList; };


// Class: AsmGenericFormat


template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecFamily,&SgAsmGenericFormat::p_family> {

  using parent = SgAsmGenericFormat;

  using field_type = SgAsmGenericFormat::ExecFamily;

  static constexpr size_t position{0};

  static constexpr char const * const name{"family"};

  static constexpr char const * const typestr{"SgAsmGenericFormat::ExecFamily"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_family};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecFamily SgAsmGenericFormat::*, &SgAsmGenericFormat::p_family>;

};


template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecPurpose,&SgAsmGenericFormat::p_purpose> {

  using parent = SgAsmGenericFormat;

  using field_type = SgAsmGenericFormat::ExecPurpose;

  static constexpr size_t position{1};

  static constexpr char const * const name{"purpose"};

  static constexpr char const * const typestr{"SgAsmGenericFormat::ExecPurpose"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_purpose};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecPurpose SgAsmGenericFormat::*, &SgAsmGenericFormat::p_purpose>;

};


template <> struct describe_field_t<SgAsmGenericFormat,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmGenericFormat::p_sex> {

  using parent = SgAsmGenericFormat;

  using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;

  static constexpr size_t position{2};

  static constexpr char const * const name{"sex"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_sex};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmGenericFormat::*, &SgAsmGenericFormat::p_sex>;

};


template <> struct describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_version> {

  using parent = SgAsmGenericFormat;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"version"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, unsigned SgAsmGenericFormat::*, &SgAsmGenericFormat::p_version>;

};


template <> struct describe_field_t<SgAsmGenericFormat,bool,&SgAsmGenericFormat::p_isCurrentVersion> {

  using parent = SgAsmGenericFormat;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"isCurrentVersion"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_isCurrentVersion};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, bool SgAsmGenericFormat::*, &SgAsmGenericFormat::p_isCurrentVersion>;

};


template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecABI,&SgAsmGenericFormat::p_abi> {

  using parent = SgAsmGenericFormat;

  using field_type = SgAsmGenericFormat::ExecABI;

  static constexpr size_t position{5};

  static constexpr char const * const name{"abi"};

  static constexpr char const * const typestr{"SgAsmGenericFormat::ExecABI"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_abi};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecABI SgAsmGenericFormat::*, &SgAsmGenericFormat::p_abi>;

};


template <> struct describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_abiVersion> {

  using parent = SgAsmGenericFormat;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"abiVersion"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_abiVersion};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, unsigned SgAsmGenericFormat::*, &SgAsmGenericFormat::p_abiVersion>;

};


template <> struct describe_field_t<SgAsmGenericFormat,size_t,&SgAsmGenericFormat::p_wordSize> {

  using parent = SgAsmGenericFormat;

  using field_type = size_t;

  static constexpr size_t position{7};

  static constexpr char const * const name{"wordSize"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_wordSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericFormat, size_t SgAsmGenericFormat::*, &SgAsmGenericFormat::p_wordSize>;

};


template <> struct describe_node_t<SgAsmGenericFormat> {

  using node = SgAsmGenericFormat;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericFormat"};

  static constexpr unsigned long variant{198};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecFamily,&SgAsmGenericFormat::p_family>, describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecPurpose,&SgAsmGenericFormat::p_purpose>, describe_field_t<SgAsmGenericFormat,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmGenericFormat::p_sex>, describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_version>, describe_field_t<SgAsmGenericFormat,bool,&SgAsmGenericFormat::p_isCurrentVersion>, describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecABI,&SgAsmGenericFormat::p_abi>, describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_abiVersion>, describe_field_t<SgAsmGenericFormat,size_t,&SgAsmGenericFormat::p_wordSize>>;

};


template <> struct node_from_variant_t<198> { using type = SgAsmGenericFormat; };


// Class: AsmGenericHeader


template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat*,&SgAsmGenericHeader::p_executableFormat> {

  using parent = SgAsmGenericHeader;

  using field_type = SgAsmGenericFormat*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"executableFormat"};

  static constexpr char const * const typestr{"SgAsmGenericFormat*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_executableFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgAsmGenericFormat* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_executableFormat>;

};


template <> struct describe_field_t<SgAsmGenericHeader,SgCharList,&SgAsmGenericHeader::p_magic> {

  using parent = SgAsmGenericHeader;

  using field_type = SgCharList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"magic"};

  static constexpr char const * const typestr{"SgCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_magic};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgCharList SgAsmGenericHeader::*, &SgAsmGenericHeader::p_magic>;

};


template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat::InsSetArchitecture,&SgAsmGenericHeader::p_isa> {

  using parent = SgAsmGenericHeader;

  using field_type = SgAsmGenericFormat::InsSetArchitecture;

  static constexpr size_t position{2};

  static constexpr char const * const name{"isa"};

  static constexpr char const * const typestr{"SgAsmGenericFormat::InsSetArchitecture"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_isa};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgAsmGenericFormat::InsSetArchitecture SgAsmGenericHeader::*, &SgAsmGenericHeader::p_isa>;

};


template <> struct describe_field_t<SgAsmGenericHeader,Rose::BinaryAnalysis::Address,&SgAsmGenericHeader::p_baseVa> {

  using parent = SgAsmGenericHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"baseVa"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_baseVa};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, Rose::BinaryAnalysis::Address SgAsmGenericHeader::*, &SgAsmGenericHeader::p_baseVa>;

};


template <> struct describe_field_t<SgAsmGenericHeader,SgRVAList,&SgAsmGenericHeader::p_entryRvas> {

  using parent = SgAsmGenericHeader;

  using field_type = SgRVAList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"entryRvas"};

  static constexpr char const * const typestr{"SgRVAList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_entryRvas};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgRVAList SgAsmGenericHeader::*, &SgAsmGenericHeader::p_entryRvas>;

};


template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericDLLList*,&SgAsmGenericHeader::p_dlls> {

  using parent = SgAsmGenericHeader;

  using field_type = SgAsmGenericDLLList*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"dlls"};

  static constexpr char const * const typestr{"SgAsmGenericDLLList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_dlls};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgAsmGenericDLLList* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_dlls>;

};


template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericSectionList*,&SgAsmGenericHeader::p_sections> {

  using parent = SgAsmGenericHeader;

  using field_type = SgAsmGenericSectionList*;

  static constexpr size_t position{6};

  static constexpr char const * const name{"sections"};

  static constexpr char const * const typestr{"SgAsmGenericSectionList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_sections};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeader, SgAsmGenericSectionList* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_sections>;

};


template <> struct describe_node_t<SgAsmGenericHeader> {

  using node = SgAsmGenericHeader;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmGenericHeader"};

  static constexpr unsigned long variant{199};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgAsmDOSFileHeader, SgAsmElfFileHeader, SgAsmJvmFileHeader, SgAsmLEFileHeader, SgAsmNEFileHeader, SgAsmPEFileHeader>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat*,&SgAsmGenericHeader::p_executableFormat>, describe_field_t<SgAsmGenericHeader,SgCharList,&SgAsmGenericHeader::p_magic>, describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat::InsSetArchitecture,&SgAsmGenericHeader::p_isa>, describe_field_t<SgAsmGenericHeader,Rose::BinaryAnalysis::Address,&SgAsmGenericHeader::p_baseVa>, describe_field_t<SgAsmGenericHeader,SgRVAList,&SgAsmGenericHeader::p_entryRvas>, describe_field_t<SgAsmGenericHeader,SgAsmGenericDLLList*,&SgAsmGenericHeader::p_dlls>, describe_field_t<SgAsmGenericHeader,SgAsmGenericSectionList*,&SgAsmGenericHeader::p_sections>>;

};


template <> struct node_from_variant_t<199> { using type = SgAsmGenericHeader; };


// Class: AsmGenericHeaderList


template <> struct describe_field_t<SgAsmGenericHeaderList,SgAsmGenericHeaderPtrList,&SgAsmGenericHeaderList::p_headers> {

  using parent = SgAsmGenericHeaderList;

  using field_type = SgAsmGenericHeaderPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"headers"};

  static constexpr char const * const typestr{"SgAsmGenericHeaderPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericHeaderList::p_headers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericHeaderList, SgAsmGenericHeaderPtrList SgAsmGenericHeaderList::*, &SgAsmGenericHeaderList::p_headers>;

};


template <> struct describe_node_t<SgAsmGenericHeaderList> {

  using node = SgAsmGenericHeaderList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericHeaderList"};

  static constexpr unsigned long variant{200};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericHeaderList,SgAsmGenericHeaderPtrList,&SgAsmGenericHeaderList::p_headers>>;

};


template <> struct node_from_variant_t<200> { using type = SgAsmGenericHeaderList; };


// Class: AsmGenericSection


template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericFile*,&SgAsmGenericSection::p_file> {

  using parent = SgAsmGenericSection;

  using field_type = SgAsmGenericFile*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"file"};

  static constexpr char const * const typestr{"SgAsmGenericFile*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_file};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, SgAsmGenericFile* SgAsmGenericSection::*, &SgAsmGenericSection::p_file>;

};


template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericHeader*,&SgAsmGenericSection::p_header> {

  using parent = SgAsmGenericSection;

  using field_type = SgAsmGenericHeader*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"header"};

  static constexpr char const * const typestr{"SgAsmGenericHeader*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_header};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, SgAsmGenericHeader* SgAsmGenericSection::*, &SgAsmGenericSection::p_header>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_size> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{2};

  static constexpr char const * const name{"size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_size>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_offset> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_offset>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_fileAlignment> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"fileAlignment"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_fileAlignment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_fileAlignment>;

};


template <> struct describe_field_t<SgAsmGenericSection,SgFileContentList,&SgAsmGenericSection::p_data> {

  using parent = SgAsmGenericSection;

  using field_type = SgFileContentList;

  static constexpr size_t position{5};

  static constexpr char const * const name{"data"};

  static constexpr char const * const typestr{"SgFileContentList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_data};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, SgFileContentList SgAsmGenericSection::*, &SgAsmGenericSection::p_data>;

};


template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericSection::SectionPurpose,&SgAsmGenericSection::p_purpose> {

  using parent = SgAsmGenericSection;

  using field_type = SgAsmGenericSection::SectionPurpose;

  static constexpr size_t position{6};

  static constexpr char const * const name{"purpose"};

  static constexpr char const * const typestr{"SgAsmGenericSection::SectionPurpose"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_purpose};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, SgAsmGenericSection::SectionPurpose SgAsmGenericSection::*, &SgAsmGenericSection::p_purpose>;

};


template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_synthesized> {

  using parent = SgAsmGenericSection;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"synthesized"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_synthesized};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_synthesized>;

};


template <> struct describe_field_t<SgAsmGenericSection,int,&SgAsmGenericSection::p_id> {

  using parent = SgAsmGenericSection;

  using field_type = int;

  static constexpr size_t position{8};

  static constexpr char const * const name{"id"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_id};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, int SgAsmGenericSection::*, &SgAsmGenericSection::p_id>;

};


template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericString*,&SgAsmGenericSection::p_name> {

  using parent = SgAsmGenericSection;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{9};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, SgAsmGenericString* SgAsmGenericSection::*, &SgAsmGenericSection::p_name>;

};


template <> struct describe_field_t<SgAsmGenericSection,std::string,&SgAsmGenericSection::p_shortName> {

  using parent = SgAsmGenericSection;

  using field_type = std::string;

  static constexpr size_t position{10};

  static constexpr char const * const name{"shortName"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_shortName};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, std::string SgAsmGenericSection::*, &SgAsmGenericSection::p_shortName>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedPreferredRva> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{11};

  static constexpr char const * const name{"mappedPreferredRva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedPreferredRva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedPreferredRva>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedSize> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{12};

  static constexpr char const * const name{"mappedSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedSize>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedAlignment> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{13};

  static constexpr char const * const name{"mappedAlignment"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedAlignment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedAlignment>;

};


template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedReadPermission> {

  using parent = SgAsmGenericSection;

  using field_type = bool;

  static constexpr size_t position{14};

  static constexpr char const * const name{"mappedReadPermission"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedReadPermission};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedReadPermission>;

};


template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedWritePermission> {

  using parent = SgAsmGenericSection;

  using field_type = bool;

  static constexpr size_t position{15};

  static constexpr char const * const name{"mappedWritePermission"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedWritePermission};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedWritePermission>;

};


template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedExecutePermission> {

  using parent = SgAsmGenericSection;

  using field_type = bool;

  static constexpr size_t position{16};

  static constexpr char const * const name{"mappedExecutePermission"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedExecutePermission};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedExecutePermission>;

};


template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_containsCode> {

  using parent = SgAsmGenericSection;

  using field_type = bool;

  static constexpr size_t position{17};

  static constexpr char const * const name{"containsCode"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_containsCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_containsCode>;

};


template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedActualVa> {

  using parent = SgAsmGenericSection;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{18};

  static constexpr char const * const name{"mappedActualVa"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedActualVa};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedActualVa>;

};


template <> struct describe_node_t<SgAsmGenericSection> {

  using node = SgAsmGenericSection;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericSection"};

  static constexpr unsigned long variant{201};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgAsmCliHeader, SgAsmCoffSymbolTable, SgAsmDOSExtendedHeader, SgAsmElfSection, SgAsmElfSectionTable, SgAsmElfSegmentTable, SgAsmGenericHeader, SgAsmJvmAttributeTable, SgAsmJvmConstantPool, SgAsmJvmFieldTable, SgAsmJvmMethodTable, SgAsmLEEntryTable, SgAsmLENameTable, SgAsmLEPageTable, SgAsmLERelocTable, SgAsmLESection, SgAsmLESectionTable, SgAsmNEEntryTable, SgAsmNEModuleTable, SgAsmNENameTable, SgAsmNERelocTable, SgAsmNESection, SgAsmNESectionTable, SgAsmNEStringTable, SgAsmPESection, SgAsmPESectionTable>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericSection,SgAsmGenericFile*,&SgAsmGenericSection::p_file>, describe_field_t<SgAsmGenericSection,SgAsmGenericHeader*,&SgAsmGenericSection::p_header>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_size>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_offset>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_fileAlignment>, describe_field_t<SgAsmGenericSection,SgFileContentList,&SgAsmGenericSection::p_data>, describe_field_t<SgAsmGenericSection,SgAsmGenericSection::SectionPurpose,&SgAsmGenericSection::p_purpose>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_synthesized>, describe_field_t<SgAsmGenericSection,int,&SgAsmGenericSection::p_id>, describe_field_t<SgAsmGenericSection,SgAsmGenericString*,&SgAsmGenericSection::p_name>, describe_field_t<SgAsmGenericSection,std::string,&SgAsmGenericSection::p_shortName>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedPreferredRva>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedSize>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedAlignment>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedReadPermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedWritePermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedExecutePermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_containsCode>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedActualVa>>;

};


template <> struct node_from_variant_t<201> { using type = SgAsmGenericSection; };


// Class: AsmGenericSectionList


template <> struct describe_field_t<SgAsmGenericSectionList,SgAsmGenericSectionPtrList,&SgAsmGenericSectionList::p_sections> {

  using parent = SgAsmGenericSectionList;

  using field_type = SgAsmGenericSectionPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"sections"};

  static constexpr char const * const typestr{"SgAsmGenericSectionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericSectionList::p_sections};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSectionList, SgAsmGenericSectionPtrList SgAsmGenericSectionList::*, &SgAsmGenericSectionList::p_sections>;

};


template <> struct describe_node_t<SgAsmGenericSectionList> {

  using node = SgAsmGenericSectionList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericSectionList"};

  static constexpr unsigned long variant{202};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericSectionList,SgAsmGenericSectionPtrList,&SgAsmGenericSectionList::p_sections>>;

};


template <> struct node_from_variant_t<202> { using type = SgAsmGenericSectionList; };


// Class: AsmGenericString


template <> struct describe_node_t<SgAsmGenericString> {

  using node = SgAsmGenericString;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericString"};

  static constexpr unsigned long variant{203};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmBasicString, SgAsmStoredString>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<203> { using type = SgAsmGenericString; };


// Class: AsmGenericStrtab


template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmGenericSection*,&SgAsmGenericStrtab::p_container> {

  using parent = SgAsmGenericStrtab;

  using field_type = SgAsmGenericSection*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"container"};

  static constexpr char const * const typestr{"SgAsmGenericSection*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_container};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericStrtab, SgAsmGenericSection* SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_container>;

};


template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmGenericStrtab::referenced_t,&SgAsmGenericStrtab::p_storageList> {

  using parent = SgAsmGenericStrtab;

  using field_type = SgAsmGenericStrtab::referenced_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"storageList"};

  static constexpr char const * const typestr{"SgAsmGenericStrtab::referenced_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_storageList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericStrtab, SgAsmGenericStrtab::referenced_t SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_storageList>;

};


template <> struct describe_field_t<SgAsmGenericStrtab,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericStrtab::p_freeList> {

  using parent = SgAsmGenericStrtab;

  using field_type = Rose::BinaryAnalysis::AddressIntervalSet;

  static constexpr size_t position{2};

  static constexpr char const * const name{"freeList"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::AddressIntervalSet"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_freeList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericStrtab, Rose::BinaryAnalysis::AddressIntervalSet SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_freeList>;

};


template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmStringStorage*,&SgAsmGenericStrtab::p_dontFree> {

  using parent = SgAsmGenericStrtab;

  using field_type = SgAsmStringStorage*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"dontFree"};

  static constexpr char const * const typestr{"SgAsmStringStorage*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_dontFree};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericStrtab, SgAsmStringStorage* SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_dontFree>;

};


template <> struct describe_field_t<SgAsmGenericStrtab,size_t,&SgAsmGenericStrtab::p_numberFreed> {

  using parent = SgAsmGenericStrtab;

  using field_type = size_t;

  static constexpr size_t position{4};

  static constexpr char const * const name{"numberFreed"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_numberFreed};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericStrtab, size_t SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_numberFreed>;

};


template <> struct describe_node_t<SgAsmGenericStrtab> {

  using node = SgAsmGenericStrtab;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericStrtab"};

  static constexpr unsigned long variant{204};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmCoffStrtab, SgAsmElfStrtab>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericStrtab,SgAsmGenericSection*,&SgAsmGenericStrtab::p_container>, describe_field_t<SgAsmGenericStrtab,SgAsmGenericStrtab::referenced_t,&SgAsmGenericStrtab::p_storageList>, describe_field_t<SgAsmGenericStrtab,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericStrtab::p_freeList>, describe_field_t<SgAsmGenericStrtab,SgAsmStringStorage*,&SgAsmGenericStrtab::p_dontFree>, describe_field_t<SgAsmGenericStrtab,size_t,&SgAsmGenericStrtab::p_numberFreed>>;

};


template <> struct node_from_variant_t<204> { using type = SgAsmGenericStrtab; };


// Class: AsmGenericSymbol


template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolDefState,&SgAsmGenericSymbol::p_definitionState> {

  using parent = SgAsmGenericSymbol;

  using field_type = SgAsmGenericSymbol::SymbolDefState;

  static constexpr size_t position{0};

  static constexpr char const * const name{"definitionState"};

  static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolDefState"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_definitionState};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolDefState SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_definitionState>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolBinding,&SgAsmGenericSymbol::p_binding> {

  using parent = SgAsmGenericSymbol;

  using field_type = SgAsmGenericSymbol::SymbolBinding;

  static constexpr size_t position{1};

  static constexpr char const * const name{"binding"};

  static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolBinding"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_binding};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolBinding SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_binding>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolType,&SgAsmGenericSymbol::p_type> {

  using parent = SgAsmGenericSymbol;

  using field_type = SgAsmGenericSymbol::SymbolType;

  static constexpr size_t position{2};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolType SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_type>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_value> {

  using parent = SgAsmGenericSymbol;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, Rose::BinaryAnalysis::Address SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_value>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_size> {

  using parent = SgAsmGenericSymbol;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, Rose::BinaryAnalysis::Address SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_size>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSection*,&SgAsmGenericSymbol::p_bound> {

  using parent = SgAsmGenericSymbol;

  using field_type = SgAsmGenericSection*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"bound"};

  static constexpr char const * const typestr{"SgAsmGenericSection*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_bound};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSection* SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_bound>;

};


template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericString*,&SgAsmGenericSymbol::p_name> {

  using parent = SgAsmGenericSymbol;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{6};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbol, SgAsmGenericString* SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_name>;

};


template <> struct describe_node_t<SgAsmGenericSymbol> {

  using node = SgAsmGenericSymbol;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericSymbol"};

  static constexpr unsigned long variant{205};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmCoffSymbol, SgAsmElfSymbol>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolDefState,&SgAsmGenericSymbol::p_definitionState>, describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolBinding,&SgAsmGenericSymbol::p_binding>, describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolType,&SgAsmGenericSymbol::p_type>, describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_value>, describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_size>, describe_field_t<SgAsmGenericSymbol,SgAsmGenericSection*,&SgAsmGenericSymbol::p_bound>, describe_field_t<SgAsmGenericSymbol,SgAsmGenericString*,&SgAsmGenericSymbol::p_name>>;

};


template <> struct node_from_variant_t<205> { using type = SgAsmGenericSymbol; };


// Class: AsmGenericSymbolList


template <> struct describe_field_t<SgAsmGenericSymbolList,SgAsmGenericSymbolPtrList,&SgAsmGenericSymbolList::p_symbols> {

  using parent = SgAsmGenericSymbolList;

  using field_type = SgAsmGenericSymbolPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"symbols"};

  static constexpr char const * const typestr{"SgAsmGenericSymbolPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmGenericSymbolList::p_symbols};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmGenericSymbolList, SgAsmGenericSymbolPtrList SgAsmGenericSymbolList::*, &SgAsmGenericSymbolList::p_symbols>;

};


template <> struct describe_node_t<SgAsmGenericSymbolList> {

  using node = SgAsmGenericSymbolList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmGenericSymbolList"};

  static constexpr unsigned long variant{206};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmGenericSymbolList,SgAsmGenericSymbolPtrList,&SgAsmGenericSymbolList::p_symbols>>;

};


template <> struct node_from_variant_t<206> { using type = SgAsmGenericSymbolList; };


// Class: AsmIndirectRegisterExpression


template <> struct describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_stride> {

  using parent = SgAsmIndirectRegisterExpression;

  using field_type = Rose::BinaryAnalysis::RegisterDescriptor;

  static constexpr size_t position{0};

  static constexpr char const * const name{"stride"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_stride};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIndirectRegisterExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_stride>;

};


template <> struct describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_offset> {

  using parent = SgAsmIndirectRegisterExpression;

  using field_type = Rose::BinaryAnalysis::RegisterDescriptor;

  static constexpr size_t position{1};

  static constexpr char const * const name{"offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIndirectRegisterExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_offset>;

};


template <> struct describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_index> {

  using parent = SgAsmIndirectRegisterExpression;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"index"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIndirectRegisterExpression, size_t SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_index>;

};


template <> struct describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_modulus> {

  using parent = SgAsmIndirectRegisterExpression;

  using field_type = size_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"modulus"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_modulus};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIndirectRegisterExpression, size_t SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_modulus>;

};


template <> struct describe_node_t<SgAsmIndirectRegisterExpression> {

  using node = SgAsmIndirectRegisterExpression;

  using base = SgAsmRegisterReferenceExpression;

  static constexpr char const * const name{"AsmIndirectRegisterExpression"};

  static constexpr unsigned long variant{207};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_stride>, describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_offset>, describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_index>, describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_modulus>>;

};


template <> struct node_from_variant_t<207> { using type = SgAsmIndirectRegisterExpression; };


// Class: AsmInstruction


template <> struct describe_field_t<SgAsmInstruction,uint8_t,&SgAsmInstruction::p_architectureId> {

  using parent = SgAsmInstruction;

  using field_type = uint8_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"architectureId"};

  static constexpr char const * const typestr{"uint8_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInstruction::p_architectureId};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInstruction, uint8_t SgAsmInstruction::*, &SgAsmInstruction::p_architectureId>;

};


template <> struct describe_field_t<SgAsmInstruction,SgUnsignedCharList,&SgAsmInstruction::p_rawBytes> {

  using parent = SgAsmInstruction;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"rawBytes"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInstruction::p_rawBytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInstruction, SgUnsignedCharList SgAsmInstruction::*, &SgAsmInstruction::p_rawBytes>;

};


template <> struct describe_field_t<SgAsmInstruction,SgAsmOperandList*,&SgAsmInstruction::p_operandList> {

  using parent = SgAsmInstruction;

  using field_type = SgAsmOperandList*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"operandList"};

  static constexpr char const * const typestr{"SgAsmOperandList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmInstruction::p_operandList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInstruction, SgAsmOperandList* SgAsmInstruction::*, &SgAsmInstruction::p_operandList>;

};


template <> struct describe_field_t<SgAsmInstruction,SgAsmInstruction*,&SgAsmInstruction::p_delaySlot> {

  using parent = SgAsmInstruction;

  using field_type = SgAsmInstruction*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"delaySlot"};

  static constexpr char const * const typestr{"SgAsmInstruction*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInstruction::p_delaySlot};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInstruction, SgAsmInstruction* SgAsmInstruction::*, &SgAsmInstruction::p_delaySlot>;

};


template <> struct describe_field_t<SgAsmInstruction,SgAsmExprListExp*,&SgAsmInstruction::p_semantics> {

  using parent = SgAsmInstruction;

  using field_type = SgAsmExprListExp*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"semantics"};

  static constexpr char const * const typestr{"SgAsmExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmInstruction::p_semantics};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInstruction, SgAsmExprListExp* SgAsmInstruction::*, &SgAsmInstruction::p_semantics>;

};


template <> struct describe_node_t<SgAsmInstruction> {

  using node = SgAsmInstruction;

  using base = SgAsmStatement;

  static constexpr char const * const name{"AsmInstruction"};

  static constexpr unsigned long variant{208};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgAsmCilInstruction, SgAsmJvmInstruction, SgAsmM68kInstruction, SgAsmMipsInstruction, SgAsmNullInstruction, SgAsmPowerpcInstruction, SgAsmUserInstruction, SgAsmX86Instruction>;

  using fields_t = mp::List<describe_field_t<SgAsmInstruction,uint8_t,&SgAsmInstruction::p_architectureId>, describe_field_t<SgAsmInstruction,SgUnsignedCharList,&SgAsmInstruction::p_rawBytes>, describe_field_t<SgAsmInstruction,SgAsmOperandList*,&SgAsmInstruction::p_operandList>, describe_field_t<SgAsmInstruction,SgAsmInstruction*,&SgAsmInstruction::p_delaySlot>, describe_field_t<SgAsmInstruction,SgAsmExprListExp*,&SgAsmInstruction::p_semantics>>;

};


template <> struct node_from_variant_t<208> { using type = SgAsmInstruction; };


// Class: AsmIntegerValueExpression


template <> struct describe_field_t<SgAsmIntegerValueExpression,SgNode*,&SgAsmIntegerValueExpression::p_baseNode> {

  using parent = SgAsmIntegerValueExpression;

  using field_type = SgNode*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"baseNode"};

  static constexpr char const * const typestr{"SgNode*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIntegerValueExpression::p_baseNode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIntegerValueExpression, SgNode* SgAsmIntegerValueExpression::*, &SgAsmIntegerValueExpression::p_baseNode>;

};


template <> struct describe_node_t<SgAsmIntegerValueExpression> {

  using node = SgAsmIntegerValueExpression;

  using base = SgAsmConstantExpression;

  static constexpr char const * const name{"AsmIntegerValueExpression"};

  static constexpr unsigned long variant{209};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmIntegerValueExpression,SgNode*,&SgAsmIntegerValueExpression::p_baseNode>>;

};


template <> struct node_from_variant_t<209> { using type = SgAsmIntegerValueExpression; };


// Class: AsmIntegerType


template <> struct describe_field_t<SgAsmIntegerType,bool,&SgAsmIntegerType::p_isSigned> {

  using parent = SgAsmIntegerType;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"isSigned"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmIntegerType::p_isSigned};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmIntegerType, bool SgAsmIntegerType::*, &SgAsmIntegerType::p_isSigned>;

};


template <> struct describe_node_t<SgAsmIntegerType> {

  using node = SgAsmIntegerType;

  using base = SgAsmScalarType;

  static constexpr char const * const name{"AsmIntegerType"};

  static constexpr unsigned long variant{210};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmIntegerType,bool,&SgAsmIntegerType::p_isSigned>>;

};


template <> struct node_from_variant_t<210> { using type = SgAsmIntegerType; };


// Class: AsmInterpretation


template <> struct describe_field_t<SgAsmInterpretation,SgAsmGenericHeaderList*,&SgAsmInterpretation::p_headers> {

  using parent = SgAsmInterpretation;

  using field_type = SgAsmGenericHeaderList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"headers"};

  static constexpr char const * const typestr{"SgAsmGenericHeaderList*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInterpretation::p_headers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInterpretation, SgAsmGenericHeaderList* SgAsmInterpretation::*, &SgAsmInterpretation::p_headers>;

};


template <> struct describe_field_t<SgAsmInterpretation,SgAsmBlock*,&SgAsmInterpretation::p_globalBlock> {

  using parent = SgAsmInterpretation;

  using field_type = SgAsmBlock*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"globalBlock"};

  static constexpr char const * const typestr{"SgAsmBlock*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmInterpretation::p_globalBlock};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInterpretation, SgAsmBlock* SgAsmInterpretation::*, &SgAsmInterpretation::p_globalBlock>;

};


template <> struct describe_field_t<SgAsmInterpretation,bool,&SgAsmInterpretation::p_coverageComputed> {

  using parent = SgAsmInterpretation;

  using field_type = bool;

  static constexpr size_t position{2};

  static constexpr char const * const name{"coverageComputed"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInterpretation::p_coverageComputed};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInterpretation, bool SgAsmInterpretation::*, &SgAsmInterpretation::p_coverageComputed>;

};


template <> struct describe_field_t<SgAsmInterpretation,double,&SgAsmInterpretation::p_percentageCoverage> {

  using parent = SgAsmInterpretation;

  using field_type = double;

  static constexpr size_t position{3};

  static constexpr char const * const name{"percentageCoverage"};

  static constexpr char const * const typestr{"double"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmInterpretation::p_percentageCoverage};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInterpretation, double SgAsmInterpretation::*, &SgAsmInterpretation::p_percentageCoverage>;

};


template <> struct describe_node_t<SgAsmInterpretation> {

  using node = SgAsmInterpretation;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmInterpretation"};

  static constexpr unsigned long variant{211};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmInterpretation,SgAsmGenericHeaderList*,&SgAsmInterpretation::p_headers>, describe_field_t<SgAsmInterpretation,SgAsmBlock*,&SgAsmInterpretation::p_globalBlock>, describe_field_t<SgAsmInterpretation,bool,&SgAsmInterpretation::p_coverageComputed>, describe_field_t<SgAsmInterpretation,double,&SgAsmInterpretation::p_percentageCoverage>>;

};


template <> struct node_from_variant_t<211> { using type = SgAsmInterpretation; };


// Class: AsmInterpretationList


template <> struct describe_field_t<SgAsmInterpretationList,SgAsmInterpretationPtrList,&SgAsmInterpretationList::p_interpretations> {

  using parent = SgAsmInterpretationList;

  using field_type = SgAsmInterpretationPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"interpretations"};

  static constexpr char const * const typestr{"SgAsmInterpretationPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmInterpretationList::p_interpretations};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmInterpretationList, SgAsmInterpretationPtrList SgAsmInterpretationList::*, &SgAsmInterpretationList::p_interpretations>;

};


template <> struct describe_node_t<SgAsmInterpretationList> {

  using node = SgAsmInterpretationList;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmInterpretationList"};

  static constexpr unsigned long variant{212};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmInterpretationList,SgAsmInterpretationPtrList,&SgAsmInterpretationList::p_interpretations>>;

};


template <> struct node_from_variant_t<212> { using type = SgAsmInterpretationList; };


// Class: AsmJvmAttribute


template <> struct describe_field_t<SgAsmJvmAttribute,uint16_t,&SgAsmJvmAttribute::p_attribute_name_index> {

  using parent = SgAsmJvmAttribute;

  using field_type = uint16_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"attribute_name_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmAttribute::p_attribute_name_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmAttribute, uint16_t SgAsmJvmAttribute::*, &SgAsmJvmAttribute::p_attribute_name_index>;

};


template <> struct describe_field_t<SgAsmJvmAttribute,uint32_t,&SgAsmJvmAttribute::p_attribute_length> {

  using parent = SgAsmJvmAttribute;

  using field_type = uint32_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"attribute_length"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmAttribute::p_attribute_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmAttribute, uint32_t SgAsmJvmAttribute::*, &SgAsmJvmAttribute::p_attribute_length>;

};


template <> struct describe_node_t<SgAsmJvmAttribute> {

  using node = SgAsmJvmAttribute;

  using base = SgAsmJvmNode;

  static constexpr char const * const name{"AsmJvmAttribute"};

  static constexpr unsigned long variant{213};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmJvmAnnotationDefault, SgAsmJvmBootstrapMethods, SgAsmJvmCodeAttribute, SgAsmJvmEnclosingMethod, SgAsmJvmIndexedAttr, SgAsmJvmIndexTableAttr, SgAsmJvmInnerClasses, SgAsmJvmLineNumberTable, SgAsmJvmLocalVariableTable, SgAsmJvmLocalVariableTypeTable, SgAsmJvmMethodParameters, SgAsmJvmModule, SgAsmJvmRuntimeInvisibleAnnotations, SgAsmJvmRuntimeVisibilityParamAnnotations, SgAsmJvmRuntimeVisibleAnnotations, SgAsmJvmStackMapTable>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmAttribute,uint16_t,&SgAsmJvmAttribute::p_attribute_name_index>, describe_field_t<SgAsmJvmAttribute,uint32_t,&SgAsmJvmAttribute::p_attribute_length>>;

};


template <> struct node_from_variant_t<213> { using type = SgAsmJvmAttribute; };


// Class: AsmJvmCodeAttribute


template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_stack> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = uint16_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"max_stack"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_max_stack};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, uint16_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_max_stack>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_locals> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = uint16_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"max_locals"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_max_locals};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, uint16_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_max_locals>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint32_t,&SgAsmJvmCodeAttribute::p_code_length> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = uint32_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"code_length"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, uint32_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code_length>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,const char*,&SgAsmJvmCodeAttribute::p_code> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = const char*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"code"};

  static constexpr char const * const typestr{"const char*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, const char* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmExceptionTable*,&SgAsmJvmCodeAttribute::p_exception_table> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = SgAsmJvmExceptionTable*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"exception_table"};

  static constexpr char const * const typestr{"SgAsmJvmExceptionTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_exception_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, SgAsmJvmExceptionTable* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_exception_table>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmAttributeTable*,&SgAsmJvmCodeAttribute::p_attribute_table> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = SgAsmJvmAttributeTable*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"attribute_table"};

  static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_attribute_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, SgAsmJvmAttributeTable* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_attribute_table>;

};


template <> struct describe_field_t<SgAsmJvmCodeAttribute,Rose::BinaryAnalysis::Address,&SgAsmJvmCodeAttribute::p_code_offset> {

  using parent = SgAsmJvmCodeAttribute;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{6};

  static constexpr char const * const name{"code_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmCodeAttribute, Rose::BinaryAnalysis::Address SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code_offset>;

};


template <> struct describe_node_t<SgAsmJvmCodeAttribute> {

  using node = SgAsmJvmCodeAttribute;

  using base = SgAsmJvmAttribute;

  static constexpr char const * const name{"AsmJvmCodeAttribute"};

  static constexpr unsigned long variant{214};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_stack>, describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_locals>, describe_field_t<SgAsmJvmCodeAttribute,uint32_t,&SgAsmJvmCodeAttribute::p_code_length>, describe_field_t<SgAsmJvmCodeAttribute,const char*,&SgAsmJvmCodeAttribute::p_code>, describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmExceptionTable*,&SgAsmJvmCodeAttribute::p_exception_table>, describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmAttributeTable*,&SgAsmJvmCodeAttribute::p_attribute_table>, describe_field_t<SgAsmJvmCodeAttribute,Rose::BinaryAnalysis::Address,&SgAsmJvmCodeAttribute::p_code_offset>>;

};


template <> struct node_from_variant_t<214> { using type = SgAsmJvmCodeAttribute; };


// Class: AsmJvmMethod


template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_access_flags> {

  using parent = SgAsmJvmMethod;

  using field_type = uint16_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"access_flags"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_access_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_access_flags>;

};


template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_name_index> {

  using parent = SgAsmJvmMethod;

  using field_type = uint16_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"name_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_name_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_name_index>;

};


template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_descriptor_index> {

  using parent = SgAsmJvmMethod;

  using field_type = uint16_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"descriptor_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_descriptor_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_descriptor_index>;

};


template <> struct describe_field_t<SgAsmJvmMethod,SgAsmJvmAttributeTable*,&SgAsmJvmMethod::p_attribute_table> {

  using parent = SgAsmJvmMethod;

  using field_type = SgAsmJvmAttributeTable*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"attribute_table"};

  static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_attribute_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmMethod, SgAsmJvmAttributeTable* SgAsmJvmMethod::*, &SgAsmJvmMethod::p_attribute_table>;

};


template <> struct describe_field_t<SgAsmJvmMethod,SgAsmInstructionList*,&SgAsmJvmMethod::p_instruction_list> {

  using parent = SgAsmJvmMethod;

  using field_type = SgAsmInstructionList*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"instruction_list"};

  static constexpr char const * const typestr{"SgAsmInstructionList*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_instruction_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmMethod, SgAsmInstructionList* SgAsmJvmMethod::*, &SgAsmJvmMethod::p_instruction_list>;

};


template <> struct describe_node_t<SgAsmJvmMethod> {

  using node = SgAsmJvmMethod;

  using base = SgAsmJvmNode;

  static constexpr char const * const name{"AsmJvmMethod"};

  static constexpr unsigned long variant{215};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_access_flags>, describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_name_index>, describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_descriptor_index>, describe_field_t<SgAsmJvmMethod,SgAsmJvmAttributeTable*,&SgAsmJvmMethod::p_attribute_table>, describe_field_t<SgAsmJvmMethod,SgAsmInstructionList*,&SgAsmJvmMethod::p_instruction_list>>;

};


template <> struct node_from_variant_t<215> { using type = SgAsmJvmMethod; };


// Class: AsmJvmConstantPool


template <> struct describe_field_t<SgAsmJvmConstantPool,SgAsmJvmConstantPoolEntryPtrList,&SgAsmJvmConstantPool::p_entries> {

  using parent = SgAsmJvmConstantPool;

  using field_type = SgAsmJvmConstantPoolEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmJvmConstantPoolEntryPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPool::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPool, SgAsmJvmConstantPoolEntryPtrList SgAsmJvmConstantPool::*, &SgAsmJvmConstantPool::p_entries>;

};


template <> struct describe_node_t<SgAsmJvmConstantPool> {

  using node = SgAsmJvmConstantPool;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmJvmConstantPool"};

  static constexpr unsigned long variant{216};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmConstantPool,SgAsmJvmConstantPoolEntryPtrList,&SgAsmJvmConstantPool::p_entries>>;

};


template <> struct node_from_variant_t<216> { using type = SgAsmJvmConstantPool; };


// Class: AsmJvmConstantPoolEntry


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,SgAsmJvmConstantPoolEntry::Kind,&SgAsmJvmConstantPoolEntry::p_tag> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = SgAsmJvmConstantPoolEntry::Kind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"tag"};

  static constexpr char const * const typestr{"SgAsmJvmConstantPoolEntry::Kind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_tag};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, SgAsmJvmConstantPoolEntry::Kind SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_tag>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_bytes> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint32_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"bytes"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_bytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_bytes>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_hi_bytes> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint32_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"hi_bytes"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_hi_bytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_hi_bytes>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_low_bytes> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint32_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"low_bytes"};

  static constexpr char const * const typestr{"uint32_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_low_bytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_low_bytes>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{4};

  static constexpr char const * const name{"bootstrap_method_attr_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_class_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{5};

  static constexpr char const * const name{"class_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_class_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_class_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_descriptor_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{6};

  static constexpr char const * const name{"descriptor_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_descriptor_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_descriptor_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{7};

  static constexpr char const * const name{"name_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_name_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_name_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_and_type_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{8};

  static constexpr char const * const name{"name_and_type_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_name_and_type_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_name_and_type_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_reference_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{9};

  static constexpr char const * const name{"reference_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_reference_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_reference_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint8_t,&SgAsmJvmConstantPoolEntry::p_reference_kind> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint8_t;

  static constexpr size_t position{10};

  static constexpr char const * const name{"reference_kind"};

  static constexpr char const * const typestr{"uint8_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_reference_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint8_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_reference_kind>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_string_index> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{11};

  static constexpr char const * const name{"string_index"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_string_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_string_index>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_length> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = uint16_t;

  static constexpr size_t position{12};

  static constexpr char const * const name{"length"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_length>;

};


template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,char*,&SgAsmJvmConstantPoolEntry::p_utf8_bytes> {

  using parent = SgAsmJvmConstantPoolEntry;

  using field_type = char*;

  static constexpr size_t position{13};

  static constexpr char const * const name{"utf8_bytes"};

  static constexpr char const * const typestr{"char*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_utf8_bytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmConstantPoolEntry, char* SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_utf8_bytes>;

};


template <> struct describe_node_t<SgAsmJvmConstantPoolEntry> {

  using node = SgAsmJvmConstantPoolEntry;

  using base = SgAsmJvmNode;

  static constexpr char const * const name{"AsmJvmConstantPoolEntry"};

  static constexpr unsigned long variant{217};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmConstantPoolEntry,SgAsmJvmConstantPoolEntry::Kind,&SgAsmJvmConstantPoolEntry::p_tag>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_hi_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_low_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_class_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_descriptor_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_and_type_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_reference_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint8_t,&SgAsmJvmConstantPoolEntry::p_reference_kind>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_string_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_length>, describe_field_t<SgAsmJvmConstantPoolEntry,char*,&SgAsmJvmConstantPoolEntry::p_utf8_bytes>>;

};


template <> struct node_from_variant_t<217> { using type = SgAsmJvmConstantPoolEntry; };


// Class: AsmJvmInstruction


template <> struct describe_field_t<SgAsmJvmInstruction,Rose::BinaryAnalysis::JvmInstructionKind,&SgAsmJvmInstruction::p_kind> {

  using parent = SgAsmJvmInstruction;

  using field_type = Rose::BinaryAnalysis::JvmInstructionKind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"kind"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::JvmInstructionKind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmInstruction::p_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmInstruction, Rose::BinaryAnalysis::JvmInstructionKind SgAsmJvmInstruction::*, &SgAsmJvmInstruction::p_kind>;

};


template <> struct describe_node_t<SgAsmJvmInstruction> {

  using node = SgAsmJvmInstruction;

  using base = SgAsmInstruction;

  static constexpr char const * const name{"AsmJvmInstruction"};

  static constexpr unsigned long variant{218};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmInstruction,Rose::BinaryAnalysis::JvmInstructionKind,&SgAsmJvmInstruction::p_kind>>;

};


template <> struct node_from_variant_t<218> { using type = SgAsmJvmInstruction; };


// Class: AsmJvmFileHeader


template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_minor_version> {

  using parent = SgAsmJvmFileHeader;

  using field_type = uint16_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"minor_version"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_minor_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_minor_version>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_major_version> {

  using parent = SgAsmJvmFileHeader;

  using field_type = uint16_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"major_version"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_major_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_major_version>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_access_flags> {

  using parent = SgAsmJvmFileHeader;

  using field_type = uint16_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"access_flags"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_access_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_access_flags>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_this_class> {

  using parent = SgAsmJvmFileHeader;

  using field_type = uint16_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"this_class"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_this_class};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_this_class>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_super_class> {

  using parent = SgAsmJvmFileHeader;

  using field_type = uint16_t;

  static constexpr size_t position{4};

  static constexpr char const * const name{"super_class"};

  static constexpr char const * const typestr{"uint16_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_super_class};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_super_class>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmConstantPool*,&SgAsmJvmFileHeader::p_constant_pool> {

  using parent = SgAsmJvmFileHeader;

  using field_type = SgAsmJvmConstantPool*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"constant_pool"};

  static constexpr char const * const typestr{"SgAsmJvmConstantPool*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_constant_pool};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmConstantPool* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_constant_pool>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,std::list<uint16_t>,&SgAsmJvmFileHeader::p_interfaces> {

  using parent = SgAsmJvmFileHeader;

  using field_type = std::list<uint16_t>;

  static constexpr size_t position{6};

  static constexpr char const * const name{"interfaces"};

  static constexpr char const * const typestr{"std::list<uint16_t>"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_interfaces};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, std::list<uint16_t> SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_interfaces>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmFieldTable*,&SgAsmJvmFileHeader::p_field_table> {

  using parent = SgAsmJvmFileHeader;

  using field_type = SgAsmJvmFieldTable*;

  static constexpr size_t position{7};

  static constexpr char const * const name{"field_table"};

  static constexpr char const * const typestr{"SgAsmJvmFieldTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_field_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmFieldTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_field_table>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmMethodTable*,&SgAsmJvmFileHeader::p_method_table> {

  using parent = SgAsmJvmFileHeader;

  using field_type = SgAsmJvmMethodTable*;

  static constexpr size_t position{8};

  static constexpr char const * const name{"method_table"};

  static constexpr char const * const typestr{"SgAsmJvmMethodTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_method_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmMethodTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_method_table>;

};


template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmAttributeTable*,&SgAsmJvmFileHeader::p_attribute_table> {

  using parent = SgAsmJvmFileHeader;

  using field_type = SgAsmJvmAttributeTable*;

  static constexpr size_t position{9};

  static constexpr char const * const name{"attribute_table"};

  static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_attribute_table};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmAttributeTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_attribute_table>;

};


template <> struct describe_node_t<SgAsmJvmFileHeader> {

  using node = SgAsmJvmFileHeader;

  using base = SgAsmGenericHeader;

  static constexpr char const * const name{"AsmJvmFileHeader"};

  static constexpr unsigned long variant{219};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_minor_version>, describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_major_version>, describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_access_flags>, describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_this_class>, describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_super_class>, describe_field_t<SgAsmJvmFileHeader,SgAsmJvmConstantPool*,&SgAsmJvmFileHeader::p_constant_pool>, describe_field_t<SgAsmJvmFileHeader,std::list<uint16_t>,&SgAsmJvmFileHeader::p_interfaces>, describe_field_t<SgAsmJvmFileHeader,SgAsmJvmFieldTable*,&SgAsmJvmFileHeader::p_field_table>, describe_field_t<SgAsmJvmFileHeader,SgAsmJvmMethodTable*,&SgAsmJvmFileHeader::p_method_table>, describe_field_t<SgAsmJvmFileHeader,SgAsmJvmAttributeTable*,&SgAsmJvmFileHeader::p_attribute_table>>;

};


template <> struct node_from_variant_t<219> { using type = SgAsmJvmFileHeader; };


// Class: AsmJvmNode


template <> struct describe_node_t<SgAsmJvmNode> {

  using node = SgAsmJvmNode;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmJvmNode"};

  static constexpr unsigned long variant{220};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmJvmAttribute, SgAsmJvmBootstrapMethod, SgAsmJvmClass, SgAsmJvmConstantPoolEntry, SgAsmJvmExceptionHandler, SgAsmJvmExceptionTable, SgAsmJvmField, SgAsmJvmLocalVariableEntry, SgAsmJvmLocalVariableTypeEntry, SgAsmJvmMethod, SgAsmJvmMethodParametersEntry, SgAsmJvmRuntimeAnnotation, SgAsmJvmRuntimeAnnotationPair, SgAsmJvmRuntimeAnnotationValue, SgAsmJvmRuntimeParameterAnnotation, SgAsmJvmStackMapFrame, SgAsmJvmStackMapVerificationType>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<220> { using type = SgAsmJvmNode; };


// Class: AsmLEEntryPoint


template <> struct describe_field_t<SgAsmLEEntryPoint,SgAsmLEEntryPointPtrList,&SgAsmLEEntryPoint::p_entries> {

  using parent = SgAsmLEEntryPoint;

  using field_type = SgAsmLEEntryPointPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmLEEntryPointPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, SgAsmLEEntryPointPtrList SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entries>;

};


template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_flags> {

  using parent = SgAsmLEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_flags>;

};


template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_objnum> {

  using parent = SgAsmLEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"objnum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_objnum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_objnum>;

};


template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_entry_type> {

  using parent = SgAsmLEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"entry_type"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entry_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entry_type>;

};


template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_res1> {

  using parent = SgAsmLEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{4};

  static constexpr char const * const name{"res1"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_res1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_res1>;

};


template <> struct describe_field_t<SgAsmLEEntryPoint,Rose::BinaryAnalysis::Address,&SgAsmLEEntryPoint::p_entry_offset> {

  using parent = SgAsmLEEntryPoint;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{5};

  static constexpr char const * const name{"entry_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entry_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryPoint, Rose::BinaryAnalysis::Address SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entry_offset>;

};


template <> struct describe_node_t<SgAsmLEEntryPoint> {

  using node = SgAsmLEEntryPoint;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmLEEntryPoint"};

  static constexpr unsigned long variant{221};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLEEntryPoint,SgAsmLEEntryPointPtrList,&SgAsmLEEntryPoint::p_entries>, describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_flags>, describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_objnum>, describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_entry_type>, describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_res1>, describe_field_t<SgAsmLEEntryPoint,Rose::BinaryAnalysis::Address,&SgAsmLEEntryPoint::p_entry_offset>>;

};


template <> struct node_from_variant_t<221> { using type = SgAsmLEEntryPoint; };


// Class: AsmLEEntryTable


template <> struct describe_field_t<SgAsmLEEntryTable,SgSizeTList,&SgAsmLEEntryTable::p_bundle_sizes> {

  using parent = SgAsmLEEntryTable;

  using field_type = SgSizeTList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"bundle_sizes"};

  static constexpr char const * const typestr{"SgSizeTList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEEntryTable::p_bundle_sizes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryTable, SgSizeTList SgAsmLEEntryTable::*, &SgAsmLEEntryTable::p_bundle_sizes>;

};


template <> struct describe_field_t<SgAsmLEEntryTable,SgAsmLEEntryPointPtrList,&SgAsmLEEntryTable::p_entries> {

  using parent = SgAsmLEEntryTable;

  using field_type = SgAsmLEEntryPointPtrList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmLEEntryPointPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEEntryTable::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEEntryTable, SgAsmLEEntryPointPtrList SgAsmLEEntryTable::*, &SgAsmLEEntryTable::p_entries>;

};


template <> struct describe_node_t<SgAsmLEEntryTable> {

  using node = SgAsmLEEntryTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLEEntryTable"};

  static constexpr unsigned long variant{222};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLEEntryTable,SgSizeTList,&SgAsmLEEntryTable::p_bundle_sizes>, describe_field_t<SgAsmLEEntryTable,SgAsmLEEntryPointPtrList,&SgAsmLEEntryTable::p_entries>>;

};


template <> struct node_from_variant_t<222> { using type = SgAsmLEEntryTable; };


// Class: AsmLEFileHeader


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_byte_order> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"e_byte_order"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_byte_order};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_byte_order>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_word_order> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"e_word_order"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_word_order};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_word_order>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_format_level> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"e_format_level"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_format_level};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_format_level>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_cpu_type> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"e_cpu_type"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_cpu_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_cpu_type>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_os_type> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{4};

  static constexpr char const * const name{"e_os_type"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_os_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_os_type>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_module_version> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{5};

  static constexpr char const * const name{"e_module_version"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_module_version};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_module_version>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_flags> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"e_flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_flags>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_eip_section> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{7};

  static constexpr char const * const name{"e_eip_section"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_eip_section};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_eip_section>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_esp_section> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{8};

  static constexpr char const * const name{"e_esp_section"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_esp_section};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_esp_section>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_last_page_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{9};

  static constexpr char const * const name{"e_last_page_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_last_page_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_last_page_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_page_offset_shift> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{10};

  static constexpr char const * const name{"e_page_offset_shift"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_page_offset_shift};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_page_offset_shift>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fixup_sect_cksum> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{11};

  static constexpr char const * const name{"e_fixup_sect_cksum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_sect_cksum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_sect_cksum>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_loader_sect_cksum> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{12};

  static constexpr char const * const name{"e_loader_sect_cksum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_loader_sect_cksum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_loader_sect_cksum>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_secttab_nentries> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{13};

  static constexpr char const * const name{"e_secttab_nentries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_secttab_nentries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_secttab_nentries>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_rsrctab_nentries> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{14};

  static constexpr char const * const name{"e_rsrctab_nentries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_rsrctab_nentries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_rsrctab_nentries>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fmtdirtab_nentries> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{15};

  static constexpr char const * const name{"e_fmtdirtab_nentries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fmtdirtab_nentries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fmtdirtab_nentries>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_import_modtab_nentries> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{16};

  static constexpr char const * const name{"e_import_modtab_nentries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_modtab_nentries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_modtab_nentries>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_preload_npages> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{17};

  static constexpr char const * const name{"e_preload_npages"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_preload_npages};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_preload_npages>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{18};

  static constexpr char const * const name{"e_nonresnametab_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_cksum> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{19};

  static constexpr char const * const name{"e_nonresnametab_cksum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_cksum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_cksum>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_auto_ds_section> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{20};

  static constexpr char const * const name{"e_auto_ds_section"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_auto_ds_section};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_auto_ds_section>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_debug_info_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{21};

  static constexpr char const * const name{"e_debug_info_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_debug_info_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_debug_info_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_preload> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{22};

  static constexpr char const * const name{"e_num_instance_preload"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_num_instance_preload};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_num_instance_preload>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_demand> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{23};

  static constexpr char const * const name{"e_num_instance_demand"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_num_instance_demand};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_num_instance_demand>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_heap_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{24};

  static constexpr char const * const name{"e_heap_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_heap_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_heap_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_npages> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{25};

  static constexpr char const * const name{"e_npages"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_npages};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_npages>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_eip> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{26};

  static constexpr char const * const name{"e_eip"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_eip};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_eip>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_esp> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{27};

  static constexpr char const * const name{"e_esp"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_esp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_esp>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_page_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{28};

  static constexpr char const * const name{"e_page_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_page_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_page_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_sect_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{29};

  static constexpr char const * const name{"e_fixup_sect_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_sect_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_sect_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_loader_sect_size> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{30};

  static constexpr char const * const name{"e_loader_sect_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_loader_sect_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_loader_sect_size>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_secttab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{31};

  static constexpr char const * const name{"e_secttab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_secttab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_secttab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_pagetab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{32};

  static constexpr char const * const name{"e_pagetab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_pagetab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_pagetab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_iterpages_offset> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{33};

  static constexpr char const * const name{"e_iterpages_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_iterpages_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_iterpages_offset>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_rsrctab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{34};

  static constexpr char const * const name{"e_rsrctab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_rsrctab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_rsrctab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_resnametab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{35};

  static constexpr char const * const name{"e_resnametab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_resnametab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_resnametab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_entrytab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{36};

  static constexpr char const * const name{"e_entrytab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_entrytab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_entrytab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fmtdirtab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{37};

  static constexpr char const * const name{"e_fmtdirtab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fmtdirtab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fmtdirtab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{38};

  static constexpr char const * const name{"e_fixup_pagetab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_pagetab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_rectab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{39};

  static constexpr char const * const name{"e_fixup_rectab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_rectab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_rectab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_modtab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{40};

  static constexpr char const * const name{"e_import_modtab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_modtab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_modtab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_proctab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{41};

  static constexpr char const * const name{"e_import_proctab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_proctab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_proctab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_ppcksumtab_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{42};

  static constexpr char const * const name{"e_ppcksumtab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_ppcksumtab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_ppcksumtab_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_data_pages_offset> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{43};

  static constexpr char const * const name{"e_data_pages_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_data_pages_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_data_pages_offset>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_nonresnametab_offset> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{44};

  static constexpr char const * const name{"e_nonresnametab_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_offset>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_debug_info_rfo> {

  using parent = SgAsmLEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{45};

  static constexpr char const * const name{"e_debug_info_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_debug_info_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_debug_info_rfo>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmLEFileHeader::p_dos2Header> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmDOSExtendedHeader*;

  static constexpr size_t position{46};

  static constexpr char const * const name{"dos2Header"};

  static constexpr char const * const typestr{"SgAsmDOSExtendedHeader*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_dos2Header};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmDOSExtendedHeader* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_dos2Header>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLESectionTable*,&SgAsmLEFileHeader::p_sectionTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLESectionTable*;

  static constexpr size_t position{47};

  static constexpr char const * const name{"sectionTable"};

  static constexpr char const * const typestr{"SgAsmLESectionTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_sectionTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLESectionTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_sectionTable>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLEPageTable*,&SgAsmLEFileHeader::p_pageTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLEPageTable*;

  static constexpr size_t position{48};

  static constexpr char const * const name{"pageTable"};

  static constexpr char const * const typestr{"SgAsmLEPageTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_pageTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLEPageTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_pageTable>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_residentNameTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLENameTable*;

  static constexpr size_t position{49};

  static constexpr char const * const name{"residentNameTable"};

  static constexpr char const * const typestr{"SgAsmLENameTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_residentNameTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLENameTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_residentNameTable>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_nonresidentNameTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLENameTable*;

  static constexpr size_t position{50};

  static constexpr char const * const name{"nonresidentNameTable"};

  static constexpr char const * const typestr{"SgAsmLENameTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_nonresidentNameTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLENameTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_nonresidentNameTable>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLEEntryTable*,&SgAsmLEFileHeader::p_entryTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLEEntryTable*;

  static constexpr size_t position{51};

  static constexpr char const * const name{"entryTable"};

  static constexpr char const * const typestr{"SgAsmLEEntryTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_entryTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLEEntryTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_entryTable>;

};


template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLERelocTable*,&SgAsmLEFileHeader::p_relocationTable> {

  using parent = SgAsmLEFileHeader;

  using field_type = SgAsmLERelocTable*;

  static constexpr size_t position{52};

  static constexpr char const * const name{"relocationTable"};

  static constexpr char const * const typestr{"SgAsmLERelocTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_relocationTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEFileHeader, SgAsmLERelocTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_relocationTable>;

};


template <> struct describe_node_t<SgAsmLEFileHeader> {

  using node = SgAsmLEFileHeader;

  using base = SgAsmGenericHeader;

  static constexpr char const * const name{"AsmLEFileHeader"};

  static constexpr unsigned long variant{223};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_byte_order>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_word_order>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_format_level>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_cpu_type>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_os_type>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_module_version>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_flags>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_eip_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_esp_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_last_page_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_page_offset_shift>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fixup_sect_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_loader_sect_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_secttab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_rsrctab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fmtdirtab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_import_modtab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_preload_npages>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_auto_ds_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_debug_info_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_preload>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_demand>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_heap_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_npages>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_eip>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_esp>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_page_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_sect_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_loader_sect_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_secttab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_pagetab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_iterpages_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_rsrctab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_resnametab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_entrytab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fmtdirtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_rectab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_modtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_proctab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_ppcksumtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_data_pages_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_nonresnametab_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_debug_info_rfo>, describe_field_t<SgAsmLEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmLEFileHeader::p_dos2Header>, describe_field_t<SgAsmLEFileHeader,SgAsmLESectionTable*,&SgAsmLEFileHeader::p_sectionTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLEPageTable*,&SgAsmLEFileHeader::p_pageTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_residentNameTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_nonresidentNameTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLEEntryTable*,&SgAsmLEFileHeader::p_entryTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLERelocTable*,&SgAsmLEFileHeader::p_relocationTable>>;

};


template <> struct node_from_variant_t<223> { using type = SgAsmLEFileHeader; };


// Class: AsmLENameTable


template <> struct describe_field_t<SgAsmLENameTable,SgStringList,&SgAsmLENameTable::p_names> {

  using parent = SgAsmLENameTable;

  using field_type = SgStringList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"names"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLENameTable::p_names};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLENameTable, SgStringList SgAsmLENameTable::*, &SgAsmLENameTable::p_names>;

};


template <> struct describe_field_t<SgAsmLENameTable,SgUnsignedList,&SgAsmLENameTable::p_ordinals> {

  using parent = SgAsmLENameTable;

  using field_type = SgUnsignedList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"ordinals"};

  static constexpr char const * const typestr{"SgUnsignedList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLENameTable::p_ordinals};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLENameTable, SgUnsignedList SgAsmLENameTable::*, &SgAsmLENameTable::p_ordinals>;

};


template <> struct describe_node_t<SgAsmLENameTable> {

  using node = SgAsmLENameTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLENameTable"};

  static constexpr unsigned long variant{224};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLENameTable,SgStringList,&SgAsmLENameTable::p_names>, describe_field_t<SgAsmLENameTable,SgUnsignedList,&SgAsmLENameTable::p_ordinals>>;

};


template <> struct node_from_variant_t<224> { using type = SgAsmLENameTable; };


// Class: AsmLEPageTable


template <> struct describe_field_t<SgAsmLEPageTable,SgAsmLEPageTableEntryPtrList,&SgAsmLEPageTable::p_entries> {

  using parent = SgAsmLEPageTable;

  using field_type = SgAsmLEPageTableEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmLEPageTableEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLEPageTable::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEPageTable, SgAsmLEPageTableEntryPtrList SgAsmLEPageTable::*, &SgAsmLEPageTable::p_entries>;

};


template <> struct describe_node_t<SgAsmLEPageTable> {

  using node = SgAsmLEPageTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLEPageTable"};

  static constexpr unsigned long variant{225};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLEPageTable,SgAsmLEPageTableEntryPtrList,&SgAsmLEPageTable::p_entries>>;

};


template <> struct node_from_variant_t<225> { using type = SgAsmLEPageTable; };


// Class: AsmLEPageTableEntry


template <> struct describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_pageno> {

  using parent = SgAsmLEPageTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"pageno"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEPageTableEntry::p_pageno};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEPageTableEntry, unsigned SgAsmLEPageTableEntry::*, &SgAsmLEPageTableEntry::p_pageno>;

};


template <> struct describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_flags> {

  using parent = SgAsmLEPageTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLEPageTableEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLEPageTableEntry, unsigned SgAsmLEPageTableEntry::*, &SgAsmLEPageTableEntry::p_flags>;

};


template <> struct describe_node_t<SgAsmLEPageTableEntry> {

  using node = SgAsmLEPageTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmLEPageTableEntry"};

  static constexpr unsigned long variant{226};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_pageno>, describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_flags>>;

};


template <> struct node_from_variant_t<226> { using type = SgAsmLEPageTableEntry; };


// Class: AsmLERelocTable


template <> struct describe_field_t<SgAsmLERelocTable,SgAsmLERelocEntryPtrList,&SgAsmLERelocTable::p_entries> {

  using parent = SgAsmLERelocTable;

  using field_type = SgAsmLERelocEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmLERelocEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLERelocTable::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLERelocTable, SgAsmLERelocEntryPtrList SgAsmLERelocTable::*, &SgAsmLERelocTable::p_entries>;

};


template <> struct describe_node_t<SgAsmLERelocTable> {

  using node = SgAsmLERelocTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLERelocTable"};

  static constexpr unsigned long variant{227};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLERelocTable,SgAsmLERelocEntryPtrList,&SgAsmLERelocTable::p_entries>>;

};


template <> struct node_from_variant_t<227> { using type = SgAsmLERelocTable; };


// Class: AsmLESection


template <> struct describe_field_t<SgAsmLESection,SgAsmLESectionTableEntry*,&SgAsmLESection::p_sectionTableEntry> {

  using parent = SgAsmLESection;

  using field_type = SgAsmLESectionTableEntry*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"sectionTableEntry"};

  static constexpr char const * const typestr{"SgAsmLESectionTableEntry*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmLESection::p_sectionTableEntry};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESection, SgAsmLESectionTableEntry* SgAsmLESection::*, &SgAsmLESection::p_sectionTableEntry>;

};


template <> struct describe_node_t<SgAsmLESection> {

  using node = SgAsmLESection;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLESection"};

  static constexpr unsigned long variant{228};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLESection,SgAsmLESectionTableEntry*,&SgAsmLESection::p_sectionTableEntry>>;

};


template <> struct node_from_variant_t<228> { using type = SgAsmLESection; };


// Class: AsmLESectionTable


template <> struct describe_node_t<SgAsmLESectionTable> {

  using node = SgAsmLESectionTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmLESectionTable"};

  static constexpr unsigned long variant{229};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<229> { using type = SgAsmLESectionTable; };


// Class: AsmLESectionTableEntry


template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_flags> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_flags>;

};


template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapIndex> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"pageMapIndex"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_pageMapIndex};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_pageMapIndex>;

};


template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapNEntries> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"pageMapNEntries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_pageMapNEntries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_pageMapNEntries>;

};


template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_res1> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"res1"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_res1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_res1>;

};


template <> struct describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_mappedSize> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"mappedSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_mappedSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_mappedSize>;

};


template <> struct describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_baseAddr> {

  using parent = SgAsmLESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{5};

  static constexpr char const * const name{"baseAddr"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_baseAddr};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmLESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_baseAddr>;

};


template <> struct describe_node_t<SgAsmLESectionTableEntry> {

  using node = SgAsmLESectionTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmLESectionTableEntry"};

  static constexpr unsigned long variant{230};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_flags>, describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapIndex>, describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapNEntries>, describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_res1>, describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_mappedSize>, describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_baseAddr>>;

};


template <> struct node_from_variant_t<230> { using type = SgAsmLESectionTableEntry; };


// Class: AsmM68kInstruction


template <> struct describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kInstructionKind,&SgAsmM68kInstruction::p_kind> {

  using parent = SgAsmM68kInstruction;

  using field_type = Rose::BinaryAnalysis::M68kInstructionKind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"kind"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::M68kInstructionKind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmM68kInstruction::p_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmM68kInstruction, Rose::BinaryAnalysis::M68kInstructionKind SgAsmM68kInstruction::*, &SgAsmM68kInstruction::p_kind>;

};


template <> struct describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kDataFormat,&SgAsmM68kInstruction::p_dataFormat> {

  using parent = SgAsmM68kInstruction;

  using field_type = Rose::BinaryAnalysis::M68kDataFormat;

  static constexpr size_t position{1};

  static constexpr char const * const name{"dataFormat"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::M68kDataFormat"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmM68kInstruction::p_dataFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmM68kInstruction, Rose::BinaryAnalysis::M68kDataFormat SgAsmM68kInstruction::*, &SgAsmM68kInstruction::p_dataFormat>;

};


template <> struct describe_node_t<SgAsmM68kInstruction> {

  using node = SgAsmM68kInstruction;

  using base = SgAsmInstruction;

  static constexpr char const * const name{"AsmM68kInstruction"};

  static constexpr unsigned long variant{231};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kInstructionKind,&SgAsmM68kInstruction::p_kind>, describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kDataFormat,&SgAsmM68kInstruction::p_dataFormat>>;

};


template <> struct node_from_variant_t<231> { using type = SgAsmM68kInstruction; };


// Class: AsmMemoryReferenceExpression


template <> struct describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_address> {

  using parent = SgAsmMemoryReferenceExpression;

  using field_type = SgAsmExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"address"};

  static constexpr char const * const typestr{"SgAsmExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmMemoryReferenceExpression::p_address};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmMemoryReferenceExpression, SgAsmExpression* SgAsmMemoryReferenceExpression::*, &SgAsmMemoryReferenceExpression::p_address>;

};


template <> struct describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_segment> {

  using parent = SgAsmMemoryReferenceExpression;

  using field_type = SgAsmExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"segment"};

  static constexpr char const * const typestr{"SgAsmExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmMemoryReferenceExpression::p_segment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmMemoryReferenceExpression, SgAsmExpression* SgAsmMemoryReferenceExpression::*, &SgAsmMemoryReferenceExpression::p_segment>;

};


template <> struct describe_node_t<SgAsmMemoryReferenceExpression> {

  using node = SgAsmMemoryReferenceExpression;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmMemoryReferenceExpression"};

  static constexpr unsigned long variant{232};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_address>, describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_segment>>;

};


template <> struct node_from_variant_t<232> { using type = SgAsmMemoryReferenceExpression; };


// Class: AsmMipsInstruction


template <> struct describe_field_t<SgAsmMipsInstruction,Rose::BinaryAnalysis::MipsInstructionKind,&SgAsmMipsInstruction::p_kind> {

  using parent = SgAsmMipsInstruction;

  using field_type = Rose::BinaryAnalysis::MipsInstructionKind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"kind"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::MipsInstructionKind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmMipsInstruction::p_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmMipsInstruction, Rose::BinaryAnalysis::MipsInstructionKind SgAsmMipsInstruction::*, &SgAsmMipsInstruction::p_kind>;

};


template <> struct describe_node_t<SgAsmMipsInstruction> {

  using node = SgAsmMipsInstruction;

  using base = SgAsmInstruction;

  static constexpr char const * const name{"AsmMipsInstruction"};

  static constexpr unsigned long variant{233};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmMipsInstruction,Rose::BinaryAnalysis::MipsInstructionKind,&SgAsmMipsInstruction::p_kind>>;

};


template <> struct node_from_variant_t<233> { using type = SgAsmMipsInstruction; };


// Class: AsmNEEntryPoint


template <> struct describe_field_t<SgAsmNEEntryPoint,SgAsmNEEntryPoint::NEEntryFlags,&SgAsmNEEntryPoint::p_flags> {

  using parent = SgAsmNEEntryPoint;

  using field_type = SgAsmNEEntryPoint::NEEntryFlags;

  static constexpr size_t position{0};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"SgAsmNEEntryPoint::NEEntryFlags"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryPoint, SgAsmNEEntryPoint::NEEntryFlags SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_flags>;

};


template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_int3f> {

  using parent = SgAsmNEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"int3f"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_int3f};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_int3f>;

};


template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionIndex> {

  using parent = SgAsmNEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"sectionIndex"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_sectionIndex};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_sectionIndex>;

};


template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionOffset> {

  using parent = SgAsmNEEntryPoint;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"sectionOffset"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_sectionOffset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_sectionOffset>;

};


template <> struct describe_node_t<SgAsmNEEntryPoint> {

  using node = SgAsmNEEntryPoint;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmNEEntryPoint"};

  static constexpr unsigned long variant{234};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNEEntryPoint,SgAsmNEEntryPoint::NEEntryFlags,&SgAsmNEEntryPoint::p_flags>, describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_int3f>, describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionIndex>, describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionOffset>>;

};


template <> struct node_from_variant_t<234> { using type = SgAsmNEEntryPoint; };


// Class: AsmNEEntryTable


template <> struct describe_field_t<SgAsmNEEntryTable,SgSizeTList,&SgAsmNEEntryTable::p_bundle_sizes> {

  using parent = SgAsmNEEntryTable;

  using field_type = SgSizeTList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"bundle_sizes"};

  static constexpr char const * const typestr{"SgSizeTList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEEntryTable::p_bundle_sizes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryTable, SgSizeTList SgAsmNEEntryTable::*, &SgAsmNEEntryTable::p_bundle_sizes>;

};


template <> struct describe_field_t<SgAsmNEEntryTable,SgAsmNEEntryPointPtrList,&SgAsmNEEntryTable::p_entries> {

  using parent = SgAsmNEEntryTable;

  using field_type = SgAsmNEEntryPointPtrList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmNEEntryPointPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEEntryTable::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEEntryTable, SgAsmNEEntryPointPtrList SgAsmNEEntryTable::*, &SgAsmNEEntryTable::p_entries>;

};


template <> struct describe_node_t<SgAsmNEEntryTable> {

  using node = SgAsmNEEntryTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNEEntryTable"};

  static constexpr unsigned long variant{235};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNEEntryTable,SgSizeTList,&SgAsmNEEntryTable::p_bundle_sizes>, describe_field_t<SgAsmNEEntryTable,SgAsmNEEntryPointPtrList,&SgAsmNEEntryTable::p_entries>>;

};


template <> struct node_from_variant_t<235> { using type = SgAsmNEEntryTable; };


// Class: AsmNEFileHeader


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_major> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"e_linker_major"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_linker_major};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_linker_major>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_minor> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"e_linker_minor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_linker_minor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_linker_minor>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_checksum> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"e_checksum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_checksum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_checksum>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags1> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"e_flags1"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_flags1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_flags1>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_autodata_sn> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{4};

  static constexpr char const * const name{"e_autodata_sn"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_autodata_sn};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_autodata_sn>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_bss_size> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{5};

  static constexpr char const * const name{"e_bss_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_bss_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_bss_size>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_stack_size> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"e_stack_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_stack_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_stack_size>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_csip> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{7};

  static constexpr char const * const name{"e_csip"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_csip};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_csip>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sssp> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{8};

  static constexpr char const * const name{"e_sssp"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sssp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sssp>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nsections> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{9};

  static constexpr char const * const name{"e_nsections"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nsections};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nsections>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmodrefs> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{10};

  static constexpr char const * const name{"e_nmodrefs"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nmodrefs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nmodrefs>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nnonresnames> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{11};

  static constexpr char const * const name{"e_nnonresnames"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nnonresnames};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nnonresnames>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmovable_entries> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{12};

  static constexpr char const * const name{"e_nmovable_entries"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nmovable_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nmovable_entries>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sector_align> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{13};

  static constexpr char const * const name{"e_sector_align"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sector_align};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sector_align>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nresources> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{14};

  static constexpr char const * const name{"e_nresources"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nresources};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nresources>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_exetype> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{15};

  static constexpr char const * const name{"e_exetype"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_exetype};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_exetype>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags2> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{16};

  static constexpr char const * const name{"e_flags2"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_flags2};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_flags2>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_res1> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{17};

  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{&SgAsmNEFileHeader::p_e_res1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_res1>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_winvers> {

  using parent = SgAsmNEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{18};

  static constexpr char const * const name{"e_winvers"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_winvers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_winvers>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{19};

  static constexpr char const * const name{"e_entrytab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_entrytab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_entrytab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_size> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{20};

  static constexpr char const * const name{"e_entrytab_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_entrytab_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_entrytab_size>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_sectab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{21};

  static constexpr char const * const name{"e_sectab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sectab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sectab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_rsrctab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{22};

  static constexpr char const * const name{"e_rsrctab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_rsrctab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_rsrctab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_resnametab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{23};

  static constexpr char const * const name{"e_resnametab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_resnametab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_resnametab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_modreftab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{24};

  static constexpr char const * const name{"e_modreftab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_modreftab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_modreftab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_importnametab_rfo> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{25};

  static constexpr char const * const name{"e_importnametab_rfo"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_importnametab_rfo};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_importnametab_rfo>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_nonresnametab_offset> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{26};

  static constexpr char const * const name{"e_nonresnametab_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nonresnametab_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nonresnametab_offset>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_sector> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{27};

  static constexpr char const * const name{"e_fastload_sector"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_fastload_sector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_fastload_sector>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_nsectors> {

  using parent = SgAsmNEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{28};

  static constexpr char const * const name{"e_fastload_nsectors"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_fastload_nsectors};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_fastload_nsectors>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmNEFileHeader::p_dos2Header> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmDOSExtendedHeader*;

  static constexpr size_t position{29};

  static constexpr char const * const name{"dos2Header"};

  static constexpr char const * const typestr{"SgAsmDOSExtendedHeader*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_dos2Header};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmDOSExtendedHeader* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_dos2Header>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNESectionTable*,&SgAsmNEFileHeader::p_sectionTable> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmNESectionTable*;

  static constexpr size_t position{30};

  static constexpr char const * const name{"sectionTable"};

  static constexpr char const * const typestr{"SgAsmNESectionTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_sectionTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmNESectionTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_sectionTable>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_residentNameTable> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmNENameTable*;

  static constexpr size_t position{31};

  static constexpr char const * const name{"residentNameTable"};

  static constexpr char const * const typestr{"SgAsmNENameTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_residentNameTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmNENameTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_residentNameTable>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_nonresidentNameTable> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmNENameTable*;

  static constexpr size_t position{32};

  static constexpr char const * const name{"nonresidentNameTable"};

  static constexpr char const * const typestr{"SgAsmNENameTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_nonresidentNameTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmNENameTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_nonresidentNameTable>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNEModuleTable*,&SgAsmNEFileHeader::p_moduleTable> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmNEModuleTable*;

  static constexpr size_t position{33};

  static constexpr char const * const name{"moduleTable"};

  static constexpr char const * const typestr{"SgAsmNEModuleTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_moduleTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmNEModuleTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_moduleTable>;

};


template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNEEntryTable*,&SgAsmNEFileHeader::p_entryTable> {

  using parent = SgAsmNEFileHeader;

  using field_type = SgAsmNEEntryTable*;

  static constexpr size_t position{34};

  static constexpr char const * const name{"entryTable"};

  static constexpr char const * const typestr{"SgAsmNEEntryTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_entryTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEFileHeader, SgAsmNEEntryTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_entryTable>;

};


template <> struct describe_node_t<SgAsmNEFileHeader> {

  using node = SgAsmNEFileHeader;

  using base = SgAsmGenericHeader;

  static constexpr char const * const name{"AsmNEFileHeader"};

  static constexpr unsigned long variant{236};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_major>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_minor>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_checksum>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags1>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_autodata_sn>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_bss_size>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_stack_size>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_csip>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sssp>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nsections>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmodrefs>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nnonresnames>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmovable_entries>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sector_align>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nresources>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_exetype>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags2>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_res1>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_winvers>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_size>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_sectab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_rsrctab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_resnametab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_modreftab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_importnametab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_nonresnametab_offset>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_sector>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_nsectors>, describe_field_t<SgAsmNEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmNEFileHeader::p_dos2Header>, describe_field_t<SgAsmNEFileHeader,SgAsmNESectionTable*,&SgAsmNEFileHeader::p_sectionTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_residentNameTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_nonresidentNameTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNEModuleTable*,&SgAsmNEFileHeader::p_moduleTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNEEntryTable*,&SgAsmNEFileHeader::p_entryTable>>;

};


template <> struct node_from_variant_t<236> { using type = SgAsmNEFileHeader; };


// Class: AsmNEModuleTable


template <> struct describe_field_t<SgAsmNEModuleTable,SgAsmNEStringTable*,&SgAsmNEModuleTable::p_strtab> {

  using parent = SgAsmNEModuleTable;

  using field_type = SgAsmNEStringTable*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"strtab"};

  static constexpr char const * const typestr{"SgAsmNEStringTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_strtab};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEModuleTable, SgAsmNEStringTable* SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_strtab>;

};


template <> struct describe_field_t<SgAsmNEModuleTable,SgAddressList,&SgAsmNEModuleTable::p_nameOffsets> {

  using parent = SgAsmNEModuleTable;

  using field_type = SgAddressList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"nameOffsets"};

  static constexpr char const * const typestr{"SgAddressList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_nameOffsets};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEModuleTable, SgAddressList SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_nameOffsets>;

};


template <> struct describe_field_t<SgAsmNEModuleTable,SgStringList,&SgAsmNEModuleTable::p_names> {

  using parent = SgAsmNEModuleTable;

  using field_type = SgStringList;

  static constexpr size_t position{2};

  static constexpr char const * const name{"names"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_names};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNEModuleTable, SgStringList SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_names>;

};


template <> struct describe_node_t<SgAsmNEModuleTable> {

  using node = SgAsmNEModuleTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNEModuleTable"};

  static constexpr unsigned long variant{237};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNEModuleTable,SgAsmNEStringTable*,&SgAsmNEModuleTable::p_strtab>, describe_field_t<SgAsmNEModuleTable,SgAddressList,&SgAsmNEModuleTable::p_nameOffsets>, describe_field_t<SgAsmNEModuleTable,SgStringList,&SgAsmNEModuleTable::p_names>>;

};


template <> struct node_from_variant_t<237> { using type = SgAsmNEModuleTable; };


// Class: AsmNENameTable


template <> struct describe_field_t<SgAsmNENameTable,SgStringList,&SgAsmNENameTable::p_names> {

  using parent = SgAsmNENameTable;

  using field_type = SgStringList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"names"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNENameTable::p_names};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNENameTable, SgStringList SgAsmNENameTable::*, &SgAsmNENameTable::p_names>;

};


template <> struct describe_field_t<SgAsmNENameTable,SgUnsignedList,&SgAsmNENameTable::p_ordinals> {

  using parent = SgAsmNENameTable;

  using field_type = SgUnsignedList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"ordinals"};

  static constexpr char const * const typestr{"SgUnsignedList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNENameTable::p_ordinals};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNENameTable, SgUnsignedList SgAsmNENameTable::*, &SgAsmNENameTable::p_ordinals>;

};


template <> struct describe_node_t<SgAsmNENameTable> {

  using node = SgAsmNENameTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNENameTable"};

  static constexpr unsigned long variant{238};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNENameTable,SgStringList,&SgAsmNENameTable::p_names>, describe_field_t<SgAsmNENameTable,SgUnsignedList,&SgAsmNENameTable::p_ordinals>>;

};


template <> struct node_from_variant_t<238> { using type = SgAsmNENameTable; };


// Class: AsmNERelocEntry


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocSrcType,&SgAsmNERelocEntry::p_src_type> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::NERelocSrcType;

  static constexpr size_t position{0};

  static constexpr char const * const name{"src_type"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocSrcType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_src_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocSrcType SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_src_type>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocModifiers,&SgAsmNERelocEntry::p_modifier> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::NERelocModifiers;

  static constexpr size_t position{1};

  static constexpr char const * const name{"modifier"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocModifiers"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_modifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocModifiers SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_modifier>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocTgtType,&SgAsmNERelocEntry::p_tgt_type> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::NERelocTgtType;

  static constexpr size_t position{2};

  static constexpr char const * const name{"tgt_type"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocTgtType"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_tgt_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocTgtType SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_tgt_type>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocFlags,&SgAsmNERelocEntry::p_flags> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::NERelocFlags;

  static constexpr size_t position{3};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocFlags"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocFlags SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_flags>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,Rose::BinaryAnalysis::Address,&SgAsmNERelocEntry::p_src_offset> {

  using parent = SgAsmNERelocEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"src_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_src_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, Rose::BinaryAnalysis::Address SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_src_offset>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iref_type,&SgAsmNERelocEntry::p_iref> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::iref_type;

  static constexpr size_t position{5};

  static constexpr char const * const name{"iref"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::iref_type"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iref};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iref_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iref>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iord_type,&SgAsmNERelocEntry::p_iord> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::iord_type;

  static constexpr size_t position{6};

  static constexpr char const * const name{"iord"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::iord_type"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iord};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iord_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iord>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iname_type,&SgAsmNERelocEntry::p_iname> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::iname_type;

  static constexpr size_t position{7};

  static constexpr char const * const name{"iname"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::iname_type"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iname};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iname_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iname>;

};


template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::osfixup_type,&SgAsmNERelocEntry::p_osfixup> {

  using parent = SgAsmNERelocEntry;

  using field_type = SgAsmNERelocEntry::osfixup_type;

  static constexpr size_t position{8};

  static constexpr char const * const name{"osfixup"};

  static constexpr char const * const typestr{"SgAsmNERelocEntry::osfixup_type"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_osfixup};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::osfixup_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_osfixup>;

};


template <> struct describe_node_t<SgAsmNERelocEntry> {

  using node = SgAsmNERelocEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmNERelocEntry"};

  static constexpr unsigned long variant{239};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocSrcType,&SgAsmNERelocEntry::p_src_type>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocModifiers,&SgAsmNERelocEntry::p_modifier>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocTgtType,&SgAsmNERelocEntry::p_tgt_type>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocFlags,&SgAsmNERelocEntry::p_flags>, describe_field_t<SgAsmNERelocEntry,Rose::BinaryAnalysis::Address,&SgAsmNERelocEntry::p_src_offset>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iref_type,&SgAsmNERelocEntry::p_iref>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iord_type,&SgAsmNERelocEntry::p_iord>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iname_type,&SgAsmNERelocEntry::p_iname>, describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::osfixup_type,&SgAsmNERelocEntry::p_osfixup>>;

};


template <> struct node_from_variant_t<239> { using type = SgAsmNERelocEntry; };


// Class: AsmNERelocTable


template <> struct describe_field_t<SgAsmNERelocTable,SgAsmNERelocEntryPtrList,&SgAsmNERelocTable::p_entries> {

  using parent = SgAsmNERelocTable;

  using field_type = SgAsmNERelocEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"entries"};

  static constexpr char const * const typestr{"SgAsmNERelocEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNERelocTable::p_entries};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNERelocTable, SgAsmNERelocEntryPtrList SgAsmNERelocTable::*, &SgAsmNERelocTable::p_entries>;

};


template <> struct describe_node_t<SgAsmNERelocTable> {

  using node = SgAsmNERelocTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNERelocTable"};

  static constexpr unsigned long variant{240};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNERelocTable,SgAsmNERelocEntryPtrList,&SgAsmNERelocTable::p_entries>>;

};


template <> struct node_from_variant_t<240> { using type = SgAsmNERelocTable; };


// Class: AsmNESection


template <> struct describe_field_t<SgAsmNESection,SgAsmNESectionTableEntry*,&SgAsmNESection::p_sectionTableEntry> {

  using parent = SgAsmNESection;

  using field_type = SgAsmNESectionTableEntry*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"sectionTableEntry"};

  static constexpr char const * const typestr{"SgAsmNESectionTableEntry*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNESection::p_sectionTableEntry};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESection, SgAsmNESectionTableEntry* SgAsmNESection::*, &SgAsmNESection::p_sectionTableEntry>;

};


template <> struct describe_field_t<SgAsmNESection,SgAsmNERelocTable*,&SgAsmNESection::p_relocationTable> {

  using parent = SgAsmNESection;

  using field_type = SgAsmNERelocTable*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"relocationTable"};

  static constexpr char const * const typestr{"SgAsmNERelocTable*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmNESection::p_relocationTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESection, SgAsmNERelocTable* SgAsmNESection::*, &SgAsmNESection::p_relocationTable>;

};


template <> struct describe_node_t<SgAsmNESection> {

  using node = SgAsmNESection;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNESection"};

  static constexpr unsigned long variant{241};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNESection,SgAsmNESectionTableEntry*,&SgAsmNESection::p_sectionTableEntry>, describe_field_t<SgAsmNESection,SgAsmNERelocTable*,&SgAsmNESection::p_relocationTable>>;

};


template <> struct node_from_variant_t<241> { using type = SgAsmNESection; };


// Class: AsmNESectionTable


template <> struct describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_flags> {

  using parent = SgAsmNESectionTable;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTable, unsigned SgAsmNESectionTable::*, &SgAsmNESectionTable::p_flags>;

};


template <> struct describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_sector> {

  using parent = SgAsmNESectionTable;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"sector"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_sector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTable, unsigned SgAsmNESectionTable::*, &SgAsmNESectionTable::p_sector>;

};


template <> struct describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_physicalSize> {

  using parent = SgAsmNESectionTable;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{2};

  static constexpr char const * const name{"physicalSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_physicalSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTable, Rose::BinaryAnalysis::Address SgAsmNESectionTable::*, &SgAsmNESectionTable::p_physicalSize>;

};


template <> struct describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_virtualSize> {

  using parent = SgAsmNESectionTable;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"virtualSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_virtualSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTable, Rose::BinaryAnalysis::Address SgAsmNESectionTable::*, &SgAsmNESectionTable::p_virtualSize>;

};


template <> struct describe_node_t<SgAsmNESectionTable> {

  using node = SgAsmNESectionTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNESectionTable"};

  static constexpr unsigned long variant{242};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_flags>, describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_sector>, describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_physicalSize>, describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_virtualSize>>;

};


template <> struct node_from_variant_t<242> { using type = SgAsmNESectionTable; };


// Class: AsmNESectionTableEntry


template <> struct describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_flags> {

  using parent = SgAsmNESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTableEntry, unsigned SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_flags>;

};


template <> struct describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_sector> {

  using parent = SgAsmNESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"sector"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_sector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTableEntry, unsigned SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_sector>;

};


template <> struct describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_physicalSize> {

  using parent = SgAsmNESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{2};

  static constexpr char const * const name{"physicalSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_physicalSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_physicalSize>;

};


template <> struct describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_virtualSize> {

  using parent = SgAsmNESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"virtualSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_virtualSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmNESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_virtualSize>;

};


template <> struct describe_node_t<SgAsmNESectionTableEntry> {

  using node = SgAsmNESectionTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmNESectionTableEntry"};

  static constexpr unsigned long variant{243};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_flags>, describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_sector>, describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_physicalSize>, describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_virtualSize>>;

};


template <> struct node_from_variant_t<243> { using type = SgAsmNESectionTableEntry; };


// Class: AsmNEStringTable


template <> struct describe_node_t<SgAsmNEStringTable> {

  using node = SgAsmNEStringTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmNEStringTable"};

  static constexpr unsigned long variant{244};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<244> { using type = SgAsmNEStringTable; };


// Class: AsmNode


template <> struct describe_node_t<SgAsmNode> {

  using node = SgAsmNode;

  using base = SgNode;

  static constexpr char const * const name{"AsmNode"};

  static constexpr unsigned long variant{245};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmCilNode, SgAsmExecutableFileFormat, SgAsmExpression, SgAsmGenericFileList, SgAsmInstructionList, SgAsmInterpretation, SgAsmInterpretationList, SgAsmJvmNode, SgAsmOperandList, SgAsmStatement, SgAsmType>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<245> { using type = SgAsmNode; };


// Class: AsmOp


template <> struct describe_field_t<SgAsmOp,SgAsmOp::asm_operand_constraint_enum,&SgAsmOp::p_constraint> {

  using parent = SgAsmOp;

  using field_type = SgAsmOp::asm_operand_constraint_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"constraint"};

  static constexpr char const * const typestr{"SgAsmOp::asm_operand_constraint_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmOp::p_constraint};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, SgAsmOp::asm_operand_constraint_enum SgAsmOp::*, &SgAsmOp::p_constraint>;

};


template <> struct describe_field_t<SgAsmOp,SgAsmOp::asm_operand_modifier_enum,&SgAsmOp::p_modifiers> {

  using parent = SgAsmOp;

  using field_type = SgAsmOp::asm_operand_modifier_enum;

  static constexpr size_t position{1};

  static constexpr char const * const name{"modifiers"};

  static constexpr char const * const typestr{"SgAsmOp::asm_operand_modifier_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmOp::p_modifiers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, SgAsmOp::asm_operand_modifier_enum SgAsmOp::*, &SgAsmOp::p_modifiers>;

};


template <> struct describe_field_t<SgAsmOp,SgExpression*,&SgAsmOp::p_expression> {

  using parent = SgAsmOp;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"expression"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmOp::p_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, SgExpression* SgAsmOp::*, &SgAsmOp::p_expression>;

};


template <> struct describe_field_t<SgAsmOp,bool,&SgAsmOp::p_recordRawAsmOperandDescriptions> {

  using parent = SgAsmOp;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"recordRawAsmOperandDescriptions"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmOp::p_recordRawAsmOperandDescriptions};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, bool SgAsmOp::*, &SgAsmOp::p_recordRawAsmOperandDescriptions>;

};


template <> struct describe_field_t<SgAsmOp,bool,&SgAsmOp::p_isOutputOperand> {

  using parent = SgAsmOp;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"isOutputOperand"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmOp::p_isOutputOperand};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, bool SgAsmOp::*, &SgAsmOp::p_isOutputOperand>;

};


template <> struct describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_constraintString> {

  using parent = SgAsmOp;

  using field_type = std::string;

  static constexpr size_t position{5};

  static constexpr char const * const name{"constraintString"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmOp::p_constraintString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, std::string SgAsmOp::*, &SgAsmOp::p_constraintString>;

};


template <> struct describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_name> {

  using parent = SgAsmOp;

  using field_type = std::string;

  static constexpr size_t position{6};

  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{&SgAsmOp::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOp, std::string SgAsmOp::*, &SgAsmOp::p_name>;

};


template <> struct describe_node_t<SgAsmOp> {

  using node = SgAsmOp;

  using base = SgExpression;

  static constexpr char const * const name{"AsmOp"};

  static constexpr unsigned long variant{246};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmOp,SgAsmOp::asm_operand_constraint_enum,&SgAsmOp::p_constraint>, describe_field_t<SgAsmOp,SgAsmOp::asm_operand_modifier_enum,&SgAsmOp::p_modifiers>, describe_field_t<SgAsmOp,SgExpression*,&SgAsmOp::p_expression>, describe_field_t<SgAsmOp,bool,&SgAsmOp::p_recordRawAsmOperandDescriptions>, describe_field_t<SgAsmOp,bool,&SgAsmOp::p_isOutputOperand>, describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_constraintString>, describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_name>>;

};


template <> struct node_from_variant_t<246> { using type = SgAsmOp; };


// Class: AsmOperandList


template <> struct describe_field_t<SgAsmOperandList,SgAsmExpressionPtrList,&SgAsmOperandList::p_operands> {

  using parent = SgAsmOperandList;

  using field_type = SgAsmExpressionPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"operands"};

  static constexpr char const * const typestr{"SgAsmExpressionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmOperandList::p_operands};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmOperandList, SgAsmExpressionPtrList SgAsmOperandList::*, &SgAsmOperandList::p_operands>;

};


template <> struct describe_node_t<SgAsmOperandList> {

  using node = SgAsmOperandList;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmOperandList"};

  static constexpr unsigned long variant{247};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmOperandList,SgAsmExpressionPtrList,&SgAsmOperandList::p_operands>>;

};


template <> struct node_from_variant_t<247> { using type = SgAsmOperandList; };


// Class: AsmPEExportDirectory


template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_res1> {

  using parent = SgAsmPEExportDirectory;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"res1"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_res1};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_res1>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,time_t,&SgAsmPEExportDirectory::p_timestamp> {

  using parent = SgAsmPEExportDirectory;

  using field_type = time_t;

  static constexpr size_t position{1};

  static constexpr char const * const name{"timestamp"};

  static constexpr char const * const typestr{"time_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_timestamp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, time_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_timestamp>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vmajor> {

  using parent = SgAsmPEExportDirectory;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"vmajor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_vmajor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_vmajor>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vminor> {

  using parent = SgAsmPEExportDirectory;

  using field_type = unsigned;

  static constexpr size_t position{3};

  static constexpr char const * const name{"vminor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_vminor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_vminor>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_name_rva> {

  using parent = SgAsmPEExportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{4};

  static constexpr char const * const name{"name_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_name_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_name_rva>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_ord_base> {

  using parent = SgAsmPEExportDirectory;

  using field_type = unsigned;

  static constexpr size_t position{5};

  static constexpr char const * const name{"ord_base"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_ord_base};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_ord_base>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_expaddr_n> {

  using parent = SgAsmPEExportDirectory;

  using field_type = size_t;

  static constexpr size_t position{6};

  static constexpr char const * const name{"expaddr_n"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_expaddr_n};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, size_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_expaddr_n>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_nameptr_n> {

  using parent = SgAsmPEExportDirectory;

  using field_type = size_t;

  static constexpr size_t position{7};

  static constexpr char const * const name{"nameptr_n"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_nameptr_n};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, size_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_nameptr_n>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_expaddr_rva> {

  using parent = SgAsmPEExportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{8};

  static constexpr char const * const name{"expaddr_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_expaddr_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_expaddr_rva>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_nameptr_rva> {

  using parent = SgAsmPEExportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{9};

  static constexpr char const * const name{"nameptr_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_nameptr_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_nameptr_rva>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_ordinals_rva> {

  using parent = SgAsmPEExportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{10};

  static constexpr char const * const name{"ordinals_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_ordinals_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_ordinals_rva>;

};


template <> struct describe_field_t<SgAsmPEExportDirectory,SgAsmGenericString*,&SgAsmPEExportDirectory::p_name> {

  using parent = SgAsmPEExportDirectory;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{11};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportDirectory, SgAsmGenericString* SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_name>;

};


template <> struct describe_node_t<SgAsmPEExportDirectory> {

  using node = SgAsmPEExportDirectory;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEExportDirectory"};

  static constexpr unsigned long variant{248};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_res1>, describe_field_t<SgAsmPEExportDirectory,time_t,&SgAsmPEExportDirectory::p_timestamp>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vmajor>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vminor>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_name_rva>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_ord_base>, describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_expaddr_n>, describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_nameptr_n>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_expaddr_rva>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_nameptr_rva>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_ordinals_rva>, describe_field_t<SgAsmPEExportDirectory,SgAsmGenericString*,&SgAsmPEExportDirectory::p_name>>;

};


template <> struct node_from_variant_t<248> { using type = SgAsmPEExportDirectory; };


// Class: AsmPEExportEntry


template <> struct describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_name> {

  using parent = SgAsmPEExportEntry;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportEntry, SgAsmGenericString* SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_name>;

};


template <> struct describe_field_t<SgAsmPEExportEntry,unsigned,&SgAsmPEExportEntry::p_ordinal> {

  using parent = SgAsmPEExportEntry;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"ordinal"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_ordinal};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportEntry, unsigned SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_ordinal>;

};


template <> struct describe_field_t<SgAsmPEExportEntry,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportEntry::p_exportRva> {

  using parent = SgAsmPEExportEntry;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{2};

  static constexpr char const * const name{"exportRva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_exportRva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportEntry, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_exportRva>;

};


template <> struct describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_forwarder> {

  using parent = SgAsmPEExportEntry;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"forwarder"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_forwarder};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportEntry, SgAsmGenericString* SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_forwarder>;

};


template <> struct describe_node_t<SgAsmPEExportEntry> {

  using node = SgAsmPEExportEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEExportEntry"};

  static constexpr unsigned long variant{249};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_name>, describe_field_t<SgAsmPEExportEntry,unsigned,&SgAsmPEExportEntry::p_ordinal>, describe_field_t<SgAsmPEExportEntry,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportEntry::p_exportRva>, describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_forwarder>>;

};


template <> struct node_from_variant_t<249> { using type = SgAsmPEExportEntry; };


// Class: AsmPEExportEntryList


template <> struct describe_field_t<SgAsmPEExportEntryList,SgAsmPEExportEntryPtrList,&SgAsmPEExportEntryList::p_exports> {

  using parent = SgAsmPEExportEntryList;

  using field_type = SgAsmPEExportEntryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"exports"};

  static constexpr char const * const typestr{"SgAsmPEExportEntryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportEntryList::p_exports};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportEntryList, SgAsmPEExportEntryPtrList SgAsmPEExportEntryList::*, &SgAsmPEExportEntryList::p_exports>;

};


template <> struct describe_node_t<SgAsmPEExportEntryList> {

  using node = SgAsmPEExportEntryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEExportEntryList"};

  static constexpr unsigned long variant{250};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEExportEntryList,SgAsmPEExportEntryPtrList,&SgAsmPEExportEntryList::p_exports>>;

};


template <> struct node_from_variant_t<250> { using type = SgAsmPEExportEntryList; };


// Class: AsmPEExportSection


template <> struct describe_field_t<SgAsmPEExportSection,SgAsmPEExportDirectory*,&SgAsmPEExportSection::p_exportDirectory> {

  using parent = SgAsmPEExportSection;

  using field_type = SgAsmPEExportDirectory*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"exportDirectory"};

  static constexpr char const * const typestr{"SgAsmPEExportDirectory*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportSection::p_exportDirectory};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportSection, SgAsmPEExportDirectory* SgAsmPEExportSection::*, &SgAsmPEExportSection::p_exportDirectory>;

};


template <> struct describe_field_t<SgAsmPEExportSection,SgAsmPEExportEntryList*,&SgAsmPEExportSection::p_exports> {

  using parent = SgAsmPEExportSection;

  using field_type = SgAsmPEExportEntryList*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"exports"};

  static constexpr char const * const typestr{"SgAsmPEExportEntryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEExportSection::p_exports};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEExportSection, SgAsmPEExportEntryList* SgAsmPEExportSection::*, &SgAsmPEExportSection::p_exports>;

};


template <> struct describe_node_t<SgAsmPEExportSection> {

  using node = SgAsmPEExportSection;

  using base = SgAsmPESection;

  static constexpr char const * const name{"AsmPEExportSection"};

  static constexpr unsigned long variant{251};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEExportSection,SgAsmPEExportDirectory*,&SgAsmPEExportSection::p_exportDirectory>, describe_field_t<SgAsmPEExportSection,SgAsmPEExportEntryList*,&SgAsmPEExportSection::p_exports>>;

};


template <> struct node_from_variant_t<251> { using type = SgAsmPEExportSection; };


// Class: AsmPEFileHeader


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_cpu_type> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{0};

  static constexpr char const * const name{"e_cpu_type"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_cpu_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_cpu_type>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_nsections> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"e_nsections"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_nsections};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_nsections>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_time> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"e_time"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_time};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_time>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_coff_symtab> {

  using parent = SgAsmPEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"e_coff_symtab"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_coff_symtab};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::Address SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_coff_symtab>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_nt_hdr_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"e_nt_hdr_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_nt_hdr_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::Address SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_nt_hdr_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_coff_nsyms> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{5};

  static constexpr char const * const name{"e_coff_nsyms"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_coff_nsyms};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_coff_nsyms>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_flags> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"e_flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_flags>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_opt_magic> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{7};

  static constexpr char const * const name{"e_opt_magic"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_opt_magic};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_opt_magic>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lmajor> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{8};

  static constexpr char const * const name{"e_lmajor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_lmajor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_lmajor>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lminor> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{9};

  static constexpr char const * const name{"e_lminor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_lminor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_lminor>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_code_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{10};

  static constexpr char const * const name{"e_code_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_code_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_code_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_data_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{11};

  static constexpr char const * const name{"e_data_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_data_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_data_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_bss_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{12};

  static constexpr char const * const name{"e_bss_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_bss_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_bss_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_code_rva> {

  using parent = SgAsmPEFileHeader;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{13};

  static constexpr char const * const name{"e_code_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_code_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_code_rva>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_data_rva> {

  using parent = SgAsmPEFileHeader;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{14};

  static constexpr char const * const name{"e_data_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_data_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_data_rva>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_section_align> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{15};

  static constexpr char const * const name{"e_section_align"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_section_align};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_section_align>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_align> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{16};

  static constexpr char const * const name{"e_file_align"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_file_align};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_file_align>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_major> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{17};

  static constexpr char const * const name{"e_os_major"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_os_major};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_os_major>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_minor> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{18};

  static constexpr char const * const name{"e_os_minor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_os_minor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_os_minor>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_major> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{19};

  static constexpr char const * const name{"e_user_major"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_user_major};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_user_major>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_minor> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{20};

  static constexpr char const * const name{"e_user_minor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_user_minor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_user_minor>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_major> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{21};

  static constexpr char const * const name{"e_subsys_major"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsys_major};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsys_major>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_minor> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{22};

  static constexpr char const * const name{"e_subsys_minor"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsys_minor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsys_minor>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_reserved9> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{23};

  static constexpr char const * const name{"e_reserved9"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_reserved9};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_reserved9>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_image_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{24};

  static constexpr char const * const name{"e_image_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_image_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_image_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_header_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{25};

  static constexpr char const * const name{"e_header_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_header_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_header_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_checksum> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{26};

  static constexpr char const * const name{"e_file_checksum"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_file_checksum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_file_checksum>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsystem> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{27};

  static constexpr char const * const name{"e_subsystem"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsystem};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsystem>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_dll_flags> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{28};

  static constexpr char const * const name{"e_dll_flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_dll_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_dll_flags>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_reserve_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{29};

  static constexpr char const * const name{"e_stack_reserve_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_stack_reserve_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_stack_reserve_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_commit_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{30};

  static constexpr char const * const name{"e_stack_commit_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_stack_commit_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_stack_commit_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_reserve_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{31};

  static constexpr char const * const name{"e_heap_reserve_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_heap_reserve_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_heap_reserve_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_commit_size> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{32};

  static constexpr char const * const name{"e_heap_commit_size"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_heap_commit_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_heap_commit_size>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_loader_flags> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{33};

  static constexpr char const * const name{"e_loader_flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_loader_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_loader_flags>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_num_rvasize_pairs> {

  using parent = SgAsmPEFileHeader;

  using field_type = unsigned;

  static constexpr size_t position{34};

  static constexpr char const * const name{"e_num_rvasize_pairs"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_num_rvasize_pairs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_num_rvasize_pairs>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmPERVASizePairList*,&SgAsmPEFileHeader::p_rvaSizePairs> {

  using parent = SgAsmPEFileHeader;

  using field_type = SgAsmPERVASizePairList*;

  static constexpr size_t position{35};

  static constexpr char const * const name{"rvaSizePairs"};

  static constexpr char const * const typestr{"SgAsmPERVASizePairList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_rvaSizePairs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, SgAsmPERVASizePairList* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_rvaSizePairs>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmPESectionTable*,&SgAsmPEFileHeader::p_sectionTable> {

  using parent = SgAsmPEFileHeader;

  using field_type = SgAsmPESectionTable*;

  static constexpr size_t position{36};

  static constexpr char const * const name{"sectionTable"};

  static constexpr char const * const typestr{"SgAsmPESectionTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_sectionTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, SgAsmPESectionTable* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_sectionTable>;

};


template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmCoffSymbolTable*,&SgAsmPEFileHeader::p_coffSymbolTable> {

  using parent = SgAsmPEFileHeader;

  using field_type = SgAsmCoffSymbolTable*;

  static constexpr size_t position{37};

  static constexpr char const * const name{"coffSymbolTable"};

  static constexpr char const * const typestr{"SgAsmCoffSymbolTable*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_coffSymbolTable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEFileHeader, SgAsmCoffSymbolTable* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_coffSymbolTable>;

};


template <> struct describe_node_t<SgAsmPEFileHeader> {

  using node = SgAsmPEFileHeader;

  using base = SgAsmGenericHeader;

  static constexpr char const * const name{"AsmPEFileHeader"};

  static constexpr unsigned long variant{252};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_cpu_type>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_nsections>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_time>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_coff_symtab>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_nt_hdr_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_coff_nsyms>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_opt_magic>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lmajor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lminor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_code_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_data_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_bss_size>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_code_rva>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_data_rva>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_section_align>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_align>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_reserved9>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_image_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_header_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_checksum>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsystem>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_dll_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_reserve_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_commit_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_reserve_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_commit_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_loader_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_num_rvasize_pairs>, describe_field_t<SgAsmPEFileHeader,SgAsmPERVASizePairList*,&SgAsmPEFileHeader::p_rvaSizePairs>, describe_field_t<SgAsmPEFileHeader,SgAsmPESectionTable*,&SgAsmPEFileHeader::p_sectionTable>, describe_field_t<SgAsmPEFileHeader,SgAsmCoffSymbolTable*,&SgAsmPEFileHeader::p_coffSymbolTable>>;

};


template <> struct node_from_variant_t<252> { using type = SgAsmPEFileHeader; };


// Class: AsmPEImportDirectory


template <> struct describe_field_t<SgAsmPEImportDirectory,SgAsmGenericString*,&SgAsmPEImportDirectory::p_dllName> {

  using parent = SgAsmPEImportDirectory;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"dllName"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dllName};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, SgAsmGenericString* SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dllName>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_dllNameRva> {

  using parent = SgAsmPEImportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{1};

  static constexpr char const * const name{"dllNameRva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dllNameRva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dllNameRva>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_dll_name_nalloc> {

  using parent = SgAsmPEImportDirectory;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"dll_name_nalloc"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dll_name_nalloc};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dll_name_nalloc>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,time_t,&SgAsmPEImportDirectory::p_time> {

  using parent = SgAsmPEImportDirectory;

  using field_type = time_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"time"};

  static constexpr char const * const typestr{"time_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_time};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, time_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_time>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,unsigned,&SgAsmPEImportDirectory::p_forwarder_chain> {

  using parent = SgAsmPEImportDirectory;

  using field_type = unsigned;

  static constexpr size_t position{4};

  static constexpr char const * const name{"forwarder_chain"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_forwarder_chain};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, unsigned SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_forwarder_chain>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_ilt_rva> {

  using parent = SgAsmPEImportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{5};

  static constexpr char const * const name{"ilt_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_ilt_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_ilt_rva>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_ilt_nalloc> {

  using parent = SgAsmPEImportDirectory;

  using field_type = size_t;

  static constexpr size_t position{6};

  static constexpr char const * const name{"ilt_nalloc"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_ilt_nalloc};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_ilt_nalloc>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_iat_rva> {

  using parent = SgAsmPEImportDirectory;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{7};

  static constexpr char const * const name{"iat_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_iat_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_iat_rva>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_iat_nalloc> {

  using parent = SgAsmPEImportDirectory;

  using field_type = size_t;

  static constexpr size_t position{8};

  static constexpr char const * const name{"iat_nalloc"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_iat_nalloc};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_iat_nalloc>;

};


template <> struct describe_field_t<SgAsmPEImportDirectory,SgAsmPEImportItemList*,&SgAsmPEImportDirectory::p_imports> {

  using parent = SgAsmPEImportDirectory;

  using field_type = SgAsmPEImportItemList*;

  static constexpr size_t position{9};

  static constexpr char const * const name{"imports"};

  static constexpr char const * const typestr{"SgAsmPEImportItemList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_imports};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectory, SgAsmPEImportItemList* SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_imports>;

};


template <> struct describe_node_t<SgAsmPEImportDirectory> {

  using node = SgAsmPEImportDirectory;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEImportDirectory"};

  static constexpr unsigned long variant{253};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEImportDirectory,SgAsmGenericString*,&SgAsmPEImportDirectory::p_dllName>, describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_dllNameRva>, describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_dll_name_nalloc>, describe_field_t<SgAsmPEImportDirectory,time_t,&SgAsmPEImportDirectory::p_time>, describe_field_t<SgAsmPEImportDirectory,unsigned,&SgAsmPEImportDirectory::p_forwarder_chain>, describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_ilt_rva>, describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_ilt_nalloc>, describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_iat_rva>, describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_iat_nalloc>, describe_field_t<SgAsmPEImportDirectory,SgAsmPEImportItemList*,&SgAsmPEImportDirectory::p_imports>>;

};


template <> struct node_from_variant_t<253> { using type = SgAsmPEImportDirectory; };


// Class: AsmPEImportDirectoryList


template <> struct describe_field_t<SgAsmPEImportDirectoryList,SgAsmPEImportDirectoryPtrList,&SgAsmPEImportDirectoryList::p_vector> {

  using parent = SgAsmPEImportDirectoryList;

  using field_type = SgAsmPEImportDirectoryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"vector"};

  static constexpr char const * const typestr{"SgAsmPEImportDirectoryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportDirectoryList::p_vector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportDirectoryList, SgAsmPEImportDirectoryPtrList SgAsmPEImportDirectoryList::*, &SgAsmPEImportDirectoryList::p_vector>;

};


template <> struct describe_node_t<SgAsmPEImportDirectoryList> {

  using node = SgAsmPEImportDirectoryList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEImportDirectoryList"};

  static constexpr unsigned long variant{254};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEImportDirectoryList,SgAsmPEImportDirectoryPtrList,&SgAsmPEImportDirectoryList::p_vector>>;

};


template <> struct node_from_variant_t<254> { using type = SgAsmPEImportDirectoryList; };


// Class: AsmPEImportItem


template <> struct describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_by_ordinal> {

  using parent = SgAsmPEImportItem;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"by_ordinal"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_by_ordinal};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, bool SgAsmPEImportItem::*, &SgAsmPEImportItem::p_by_ordinal>;

};


template <> struct describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_ordinal> {

  using parent = SgAsmPEImportItem;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"ordinal"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_ordinal};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, unsigned SgAsmPEImportItem::*, &SgAsmPEImportItem::p_ordinal>;

};


template <> struct describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_hint> {

  using parent = SgAsmPEImportItem;

  using field_type = unsigned;

  static constexpr size_t position{2};

  static constexpr char const * const name{"hint"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hint};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, unsigned SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hint>;

};


template <> struct describe_field_t<SgAsmPEImportItem,SgAsmGenericString*,&SgAsmPEImportItem::p_name> {

  using parent = SgAsmPEImportItem;

  using field_type = SgAsmGenericString*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgAsmGenericString*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, SgAsmGenericString* SgAsmPEImportItem::*, &SgAsmPEImportItem::p_name>;

};


template <> struct describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_hintname_rva> {

  using parent = SgAsmPEImportItem;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{4};

  static constexpr char const * const name{"hintname_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hintname_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hintname_rva>;

};


template <> struct describe_field_t<SgAsmPEImportItem,size_t,&SgAsmPEImportItem::p_hintname_nalloc> {

  using parent = SgAsmPEImportItem;

  using field_type = size_t;

  static constexpr size_t position{5};

  static constexpr char const * const name{"hintname_nalloc"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hintname_nalloc};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, size_t SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hintname_nalloc>;

};


template <> struct describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_bound_rva> {

  using parent = SgAsmPEImportItem;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{6};

  static constexpr char const * const name{"bound_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_bound_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportItem::*, &SgAsmPEImportItem::p_bound_rva>;

};


template <> struct describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_iat_written> {

  using parent = SgAsmPEImportItem;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"iat_written"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_iat_written};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItem, bool SgAsmPEImportItem::*, &SgAsmPEImportItem::p_iat_written>;

};


template <> struct describe_node_t<SgAsmPEImportItem> {

  using node = SgAsmPEImportItem;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEImportItem"};

  static constexpr unsigned long variant{255};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_by_ordinal>, describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_ordinal>, describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_hint>, describe_field_t<SgAsmPEImportItem,SgAsmGenericString*,&SgAsmPEImportItem::p_name>, describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_hintname_rva>, describe_field_t<SgAsmPEImportItem,size_t,&SgAsmPEImportItem::p_hintname_nalloc>, describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_bound_rva>, describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_iat_written>>;

};


template <> struct node_from_variant_t<255> { using type = SgAsmPEImportItem; };


// Class: AsmPEImportItemList


template <> struct describe_field_t<SgAsmPEImportItemList,SgAsmPEImportItemPtrList,&SgAsmPEImportItemList::p_vector> {

  using parent = SgAsmPEImportItemList;

  using field_type = SgAsmPEImportItemPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"vector"};

  static constexpr char const * const typestr{"SgAsmPEImportItemPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportItemList::p_vector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportItemList, SgAsmPEImportItemPtrList SgAsmPEImportItemList::*, &SgAsmPEImportItemList::p_vector>;

};


template <> struct describe_node_t<SgAsmPEImportItemList> {

  using node = SgAsmPEImportItemList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPEImportItemList"};

  static constexpr unsigned long variant{256};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEImportItemList,SgAsmPEImportItemPtrList,&SgAsmPEImportItemList::p_vector>>;

};


template <> struct node_from_variant_t<256> { using type = SgAsmPEImportItemList; };


// Class: AsmPEImportSection


template <> struct describe_field_t<SgAsmPEImportSection,SgAsmPEImportDirectoryList*,&SgAsmPEImportSection::p_importDirectories> {

  using parent = SgAsmPEImportSection;

  using field_type = SgAsmPEImportDirectoryList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"importDirectories"};

  static constexpr char const * const typestr{"SgAsmPEImportDirectoryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPEImportSection::p_importDirectories};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEImportSection, SgAsmPEImportDirectoryList* SgAsmPEImportSection::*, &SgAsmPEImportSection::p_importDirectories>;

};


template <> struct describe_node_t<SgAsmPEImportSection> {

  using node = SgAsmPEImportSection;

  using base = SgAsmPESection;

  static constexpr char const * const name{"AsmPEImportSection"};

  static constexpr unsigned long variant{257};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEImportSection,SgAsmPEImportDirectoryList*,&SgAsmPEImportSection::p_importDirectories>>;

};


template <> struct node_from_variant_t<257> { using type = SgAsmPEImportSection; };


// Class: AsmPERVASizePair


template <> struct describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPERVASizePair::p_e_rva> {

  using parent = SgAsmPERVASizePair;

  using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;

  static constexpr size_t position{0};

  static constexpr char const * const name{"e_rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_e_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPERVASizePair, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_e_rva>;

};


template <> struct describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::Address,&SgAsmPERVASizePair::p_e_size> {

  using parent = SgAsmPERVASizePair;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{1};

  static constexpr char const * const name{"e_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_e_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPERVASizePair, Rose::BinaryAnalysis::Address SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_e_size>;

};


template <> struct describe_field_t<SgAsmPERVASizePair,SgAsmGenericSection*,&SgAsmPERVASizePair::p_section> {

  using parent = SgAsmPERVASizePair;

  using field_type = SgAsmGenericSection*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"section"};

  static constexpr char const * const typestr{"SgAsmGenericSection*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_section};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPERVASizePair, SgAsmGenericSection* SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_section>;

};


template <> struct describe_node_t<SgAsmPERVASizePair> {

  using node = SgAsmPERVASizePair;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPERVASizePair"};

  static constexpr unsigned long variant{258};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPERVASizePair::p_e_rva>, describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::Address,&SgAsmPERVASizePair::p_e_size>, describe_field_t<SgAsmPERVASizePair,SgAsmGenericSection*,&SgAsmPERVASizePair::p_section>>;

};


template <> struct node_from_variant_t<258> { using type = SgAsmPERVASizePair; };


// Class: AsmPERVASizePairList


template <> struct describe_field_t<SgAsmPERVASizePairList,SgAsmPERVASizePairPtrList,&SgAsmPERVASizePairList::p_pairs> {

  using parent = SgAsmPERVASizePairList;

  using field_type = SgAsmPERVASizePairPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"pairs"};

  static constexpr char const * const typestr{"SgAsmPERVASizePairPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPERVASizePairList::p_pairs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPERVASizePairList, SgAsmPERVASizePairPtrList SgAsmPERVASizePairList::*, &SgAsmPERVASizePairList::p_pairs>;

};


template <> struct describe_node_t<SgAsmPERVASizePairList> {

  using node = SgAsmPERVASizePairList;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPERVASizePairList"};

  static constexpr unsigned long variant{259};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPERVASizePairList,SgAsmPERVASizePairPtrList,&SgAsmPERVASizePairList::p_pairs>>;

};


template <> struct node_from_variant_t<259> { using type = SgAsmPERVASizePairList; };


// Class: AsmPESection


template <> struct describe_field_t<SgAsmPESection,SgAsmPESectionTableEntry*,&SgAsmPESection::p_section_entry> {

  using parent = SgAsmPESection;

  using field_type = SgAsmPESectionTableEntry*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"section_entry"};

  static constexpr char const * const typestr{"SgAsmPESectionTableEntry*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmPESection::p_section_entry};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESection, SgAsmPESectionTableEntry* SgAsmPESection::*, &SgAsmPESection::p_section_entry>;

};


template <> struct describe_node_t<SgAsmPESection> {

  using node = SgAsmPESection;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmPESection"};

  static constexpr unsigned long variant{260};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgAsmPEExportSection, SgAsmPEImportSection, SgAsmPEStringSection>;

  using fields_t = mp::List<describe_field_t<SgAsmPESection,SgAsmPESectionTableEntry*,&SgAsmPESection::p_section_entry>>;

};


template <> struct node_from_variant_t<260> { using type = SgAsmPESection; };


// Class: AsmPESectionTable


template <> struct describe_node_t<SgAsmPESectionTable> {

  using node = SgAsmPESectionTable;

  using base = SgAsmGenericSection;

  static constexpr char const * const name{"AsmPESectionTable"};

  static constexpr unsigned long variant{261};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<261> { using type = SgAsmPESectionTable; };


// Class: AsmPESectionTableEntry


template <> struct describe_field_t<SgAsmPESectionTableEntry,std::string,&SgAsmPESectionTableEntry::p_name> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = std::string;

  static constexpr size_t position{0};

  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{&SgAsmPESectionTableEntry::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, std::string SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_name>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_virtual_size> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{1};

  static constexpr char const * const name{"virtual_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_virtual_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_virtual_size>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_rva> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{2};

  static constexpr char const * const name{"rva"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_rva};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_rva>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_size> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{3};

  static constexpr char const * const name{"physical_size"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_physical_size};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_physical_size>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_offset> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{4};

  static constexpr char const * const name{"physical_offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_physical_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_physical_offset>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_coff_line_nums> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{5};

  static constexpr char const * const name{"coff_line_nums"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_coff_line_nums};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_coff_line_nums>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_relocs> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{6};

  static constexpr char const * const name{"n_relocs"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_n_relocs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_n_relocs>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_coff_line_nums> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{7};

  static constexpr char const * const name{"n_coff_line_nums"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_n_coff_line_nums};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_n_coff_line_nums>;

};


template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_flags> {

  using parent = SgAsmPESectionTableEntry;

  using field_type = unsigned;

  static constexpr size_t position{8};

  static constexpr char const * const name{"flags"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_flags};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_flags>;

};


template <> struct describe_node_t<SgAsmPESectionTableEntry> {

  using node = SgAsmPESectionTableEntry;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmPESectionTableEntry"};

  static constexpr unsigned long variant{262};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPESectionTableEntry,std::string,&SgAsmPESectionTableEntry::p_name>, describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_virtual_size>, describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_rva>, describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_size>, describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_offset>, describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_coff_line_nums>, describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_relocs>, describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_coff_line_nums>, describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_flags>>;

};


template <> struct node_from_variant_t<262> { using type = SgAsmPESectionTableEntry; };


// Class: AsmPEStringSection


template <> struct describe_field_t<SgAsmPEStringSection,SgAsmCoffStrtab*,&SgAsmPEStringSection::p_strtab> {

  using parent = SgAsmPEStringSection;

  using field_type = SgAsmCoffStrtab*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"strtab"};

  static constexpr char const * const typestr{"SgAsmCoffStrtab*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPEStringSection::p_strtab};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPEStringSection, SgAsmCoffStrtab* SgAsmPEStringSection::*, &SgAsmPEStringSection::p_strtab>;

};


template <> struct describe_node_t<SgAsmPEStringSection> {

  using node = SgAsmPEStringSection;

  using base = SgAsmPESection;

  static constexpr char const * const name{"AsmPEStringSection"};

  static constexpr unsigned long variant{263};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPEStringSection,SgAsmCoffStrtab*,&SgAsmPEStringSection::p_strtab>>;

};


template <> struct node_from_variant_t<263> { using type = SgAsmPEStringSection; };


// Class: AsmPowerpcInstruction


template <> struct describe_field_t<SgAsmPowerpcInstruction,Rose::BinaryAnalysis::PowerpcInstructionKind,&SgAsmPowerpcInstruction::p_kind> {

  using parent = SgAsmPowerpcInstruction;

  using field_type = Rose::BinaryAnalysis::PowerpcInstructionKind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"kind"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::PowerpcInstructionKind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmPowerpcInstruction::p_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmPowerpcInstruction, Rose::BinaryAnalysis::PowerpcInstructionKind SgAsmPowerpcInstruction::*, &SgAsmPowerpcInstruction::p_kind>;

};


template <> struct describe_node_t<SgAsmPowerpcInstruction> {

  using node = SgAsmPowerpcInstruction;

  using base = SgAsmInstruction;

  static constexpr char const * const name{"AsmPowerpcInstruction"};

  static constexpr unsigned long variant{264};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmPowerpcInstruction,Rose::BinaryAnalysis::PowerpcInstructionKind,&SgAsmPowerpcInstruction::p_kind>>;

};


template <> struct node_from_variant_t<264> { using type = SgAsmPowerpcInstruction; };


// Class: AsmRegisterNames


template <> struct describe_field_t<SgAsmRegisterNames,SgAsmRegisterReferenceExpressionPtrList,&SgAsmRegisterNames::p_registers> {

  using parent = SgAsmRegisterNames;

  using field_type = SgAsmRegisterReferenceExpressionPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"registers"};

  static constexpr char const * const typestr{"SgAsmRegisterReferenceExpressionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmRegisterNames::p_registers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRegisterNames, SgAsmRegisterReferenceExpressionPtrList SgAsmRegisterNames::*, &SgAsmRegisterNames::p_registers>;

};


template <> struct describe_field_t<SgAsmRegisterNames,unsigned,&SgAsmRegisterNames::p_mask> {

  using parent = SgAsmRegisterNames;

  using field_type = unsigned;

  static constexpr size_t position{1};

  static constexpr char const * const name{"mask"};

  static constexpr char const * const typestr{"unsigned"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmRegisterNames::p_mask};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRegisterNames, unsigned SgAsmRegisterNames::*, &SgAsmRegisterNames::p_mask>;

};


template <> struct describe_node_t<SgAsmRegisterNames> {

  using node = SgAsmRegisterNames;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmRegisterNames"};

  static constexpr unsigned long variant{265};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmRegisterNames,SgAsmRegisterReferenceExpressionPtrList,&SgAsmRegisterNames::p_registers>, describe_field_t<SgAsmRegisterNames,unsigned,&SgAsmRegisterNames::p_mask>>;

};


template <> struct node_from_variant_t<265> { using type = SgAsmRegisterNames; };


// Class: AsmRegisterReferenceExpression


template <> struct describe_field_t<SgAsmRegisterReferenceExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmRegisterReferenceExpression::p_descriptor> {

  using parent = SgAsmRegisterReferenceExpression;

  using field_type = Rose::BinaryAnalysis::RegisterDescriptor;

  static constexpr size_t position{0};

  static constexpr char const * const name{"descriptor"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmRegisterReferenceExpression::p_descriptor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRegisterReferenceExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmRegisterReferenceExpression::*, &SgAsmRegisterReferenceExpression::p_descriptor>;

};


template <> struct describe_field_t<SgAsmRegisterReferenceExpression,int,&SgAsmRegisterReferenceExpression::p_adjustment> {

  using parent = SgAsmRegisterReferenceExpression;

  using field_type = int;

  static constexpr size_t position{1};

  static constexpr char const * const name{"adjustment"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmRegisterReferenceExpression::p_adjustment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRegisterReferenceExpression, int SgAsmRegisterReferenceExpression::*, &SgAsmRegisterReferenceExpression::p_adjustment>;

};


template <> struct describe_node_t<SgAsmRegisterReferenceExpression> {

  using node = SgAsmRegisterReferenceExpression;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmRegisterReferenceExpression"};

  static constexpr unsigned long variant{266};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmDirectRegisterExpression, SgAsmIndirectRegisterExpression>;

  using fields_t = mp::List<describe_field_t<SgAsmRegisterReferenceExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmRegisterReferenceExpression::p_descriptor>, describe_field_t<SgAsmRegisterReferenceExpression,int,&SgAsmRegisterReferenceExpression::p_adjustment>>;

};


template <> struct node_from_variant_t<266> { using type = SgAsmRegisterReferenceExpression; };


// Class: AsmRiscOperation


template <> struct describe_field_t<SgAsmRiscOperation,SgAsmRiscOperation::RiscOperator,&SgAsmRiscOperation::p_riscOperator> {

  using parent = SgAsmRiscOperation;

  using field_type = SgAsmRiscOperation::RiscOperator;

  static constexpr size_t position{0};

  static constexpr char const * const name{"riscOperator"};

  static constexpr char const * const typestr{"SgAsmRiscOperation::RiscOperator"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmRiscOperation::p_riscOperator};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRiscOperation, SgAsmRiscOperation::RiscOperator SgAsmRiscOperation::*, &SgAsmRiscOperation::p_riscOperator>;

};


template <> struct describe_field_t<SgAsmRiscOperation,SgAsmExprListExp*,&SgAsmRiscOperation::p_operands> {

  using parent = SgAsmRiscOperation;

  using field_type = SgAsmExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"operands"};

  static constexpr char const * const typestr{"SgAsmExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmRiscOperation::p_operands};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmRiscOperation, SgAsmExprListExp* SgAsmRiscOperation::*, &SgAsmRiscOperation::p_operands>;

};


template <> struct describe_node_t<SgAsmRiscOperation> {

  using node = SgAsmRiscOperation;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmRiscOperation"};

  static constexpr unsigned long variant{267};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmRiscOperation,SgAsmRiscOperation::RiscOperator,&SgAsmRiscOperation::p_riscOperator>, describe_field_t<SgAsmRiscOperation,SgAsmExprListExp*,&SgAsmRiscOperation::p_operands>>;

};


template <> struct node_from_variant_t<267> { using type = SgAsmRiscOperation; };


// Class: AsmScalarType


template <> struct describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_minorOrder> {

  using parent = SgAsmScalarType;

  using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;

  static constexpr size_t position{0};

  static constexpr char const * const name{"minorOrder"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmScalarType::p_minorOrder};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmScalarType, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmScalarType::*, &SgAsmScalarType::p_minorOrder>;

};


template <> struct describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_majorOrder> {

  using parent = SgAsmScalarType;

  using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;

  static constexpr size_t position{1};

  static constexpr char const * const name{"majorOrder"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmScalarType::p_majorOrder};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmScalarType, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmScalarType::*, &SgAsmScalarType::p_majorOrder>;

};


template <> struct describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_majorNBytes> {

  using parent = SgAsmScalarType;

  using field_type = size_t;

  static constexpr size_t position{2};

  static constexpr char const * const name{"majorNBytes"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmScalarType::p_majorNBytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmScalarType, size_t SgAsmScalarType::*, &SgAsmScalarType::p_majorNBytes>;

};


template <> struct describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_nBits> {

  using parent = SgAsmScalarType;

  using field_type = size_t;

  static constexpr size_t position{3};

  static constexpr char const * const name{"nBits"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmScalarType::p_nBits};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmScalarType, size_t SgAsmScalarType::*, &SgAsmScalarType::p_nBits>;

};


template <> struct describe_node_t<SgAsmScalarType> {

  using node = SgAsmScalarType;

  using base = SgAsmType;

  static constexpr char const * const name{"AsmScalarType"};

  static constexpr unsigned long variant{268};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmFloatType, SgAsmIntegerType, SgAsmPointerType>;

  using fields_t = mp::List<describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_minorOrder>, describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_majorOrder>, describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_majorNBytes>, describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_nBits>>;

};


template <> struct node_from_variant_t<268> { using type = SgAsmScalarType; };


// Class: AsmStatement


template <> struct describe_field_t<SgAsmStatement,Rose::BinaryAnalysis::Address,&SgAsmStatement::p_address> {

  using parent = SgAsmStatement;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{0};

  static constexpr char const * const name{"address"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStatement::p_address};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStatement, Rose::BinaryAnalysis::Address SgAsmStatement::*, &SgAsmStatement::p_address>;

};


template <> struct describe_field_t<SgAsmStatement,std::string,&SgAsmStatement::p_comment> {

  using parent = SgAsmStatement;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"comment"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStatement::p_comment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStatement, std::string SgAsmStatement::*, &SgAsmStatement::p_comment>;

};


template <> struct describe_node_t<SgAsmStatement> {

  using node = SgAsmStatement;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmStatement"};

  static constexpr unsigned long variant{269};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmBlock, SgAsmInstruction, SgAsmStaticData, SgAsmSynthesizedDeclaration>;

  using fields_t = mp::List<describe_field_t<SgAsmStatement,Rose::BinaryAnalysis::Address,&SgAsmStatement::p_address>, describe_field_t<SgAsmStatement,std::string,&SgAsmStatement::p_comment>>;

};


template <> struct node_from_variant_t<269> { using type = SgAsmStatement; };


// Class: AsmStaticData


template <> struct describe_field_t<SgAsmStaticData,SgUnsignedCharList,&SgAsmStaticData::p_rawBytes> {

  using parent = SgAsmStaticData;

  using field_type = SgUnsignedCharList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"rawBytes"};

  static constexpr char const * const typestr{"SgUnsignedCharList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStaticData::p_rawBytes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStaticData, SgUnsignedCharList SgAsmStaticData::*, &SgAsmStaticData::p_rawBytes>;

};


template <> struct describe_node_t<SgAsmStaticData> {

  using node = SgAsmStaticData;

  using base = SgAsmStatement;

  static constexpr char const * const name{"AsmStaticData"};

  static constexpr unsigned long variant{270};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmStaticData,SgUnsignedCharList,&SgAsmStaticData::p_rawBytes>>;

};


template <> struct node_from_variant_t<270> { using type = SgAsmStaticData; };


// Class: AsmStmt


template <> struct describe_field_t<SgAsmStmt,std::string,&SgAsmStmt::p_assemblyCode> {

  using parent = SgAsmStmt;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"assemblyCode"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStmt::p_assemblyCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStmt, std::string SgAsmStmt::*, &SgAsmStmt::p_assemblyCode>;

};


template <> struct describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_useGnuExtendedFormat> {

  using parent = SgAsmStmt;

  using field_type = bool;

  static constexpr size_t position{1};

  static constexpr char const * const name{"useGnuExtendedFormat"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStmt::p_useGnuExtendedFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStmt, bool SgAsmStmt::*, &SgAsmStmt::p_useGnuExtendedFormat>;

};


template <> struct describe_field_t<SgAsmStmt,SgExpressionPtrList,&SgAsmStmt::p_operands> {

  using parent = SgAsmStmt;

  using field_type = SgExpressionPtrList;

  static constexpr size_t position{2};

  static constexpr char const * const name{"operands"};

  static constexpr char const * const typestr{"SgExpressionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmStmt::p_operands};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStmt, SgExpressionPtrList SgAsmStmt::*, &SgAsmStmt::p_operands>;

};


template <> struct describe_field_t<SgAsmStmt,SgAsmStmt::AsmRegisterNameList,&SgAsmStmt::p_clobberRegisterList> {

  using parent = SgAsmStmt;

  using field_type = SgAsmStmt::AsmRegisterNameList;

  static constexpr size_t position{3};

  static constexpr char const * const name{"clobberRegisterList"};

  static constexpr char const * const typestr{"SgAsmStmt::AsmRegisterNameList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStmt::p_clobberRegisterList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStmt, SgAsmStmt::AsmRegisterNameList SgAsmStmt::*, &SgAsmStmt::p_clobberRegisterList>;

};


template <> struct describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_isVolatile> {

  using parent = SgAsmStmt;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"isVolatile"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStmt::p_isVolatile};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStmt, bool SgAsmStmt::*, &SgAsmStmt::p_isVolatile>;

};


template <> struct describe_node_t<SgAsmStmt> {

  using node = SgAsmStmt;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"AsmStmt"};

  static constexpr unsigned long variant{271};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmStmt,std::string,&SgAsmStmt::p_assemblyCode>, describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_useGnuExtendedFormat>, describe_field_t<SgAsmStmt,SgExpressionPtrList,&SgAsmStmt::p_operands>, describe_field_t<SgAsmStmt,SgAsmStmt::AsmRegisterNameList,&SgAsmStmt::p_clobberRegisterList>, describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_isVolatile>>;

};


template <> struct node_from_variant_t<271> { using type = SgAsmStmt; };


// Class: AsmStoredString


template <> struct describe_field_t<SgAsmStoredString,SgAsmStringStorage*,&SgAsmStoredString::p_storage> {

  using parent = SgAsmStoredString;

  using field_type = SgAsmStringStorage*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"storage"};

  static constexpr char const * const typestr{"SgAsmStringStorage*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStoredString::p_storage};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStoredString, SgAsmStringStorage* SgAsmStoredString::*, &SgAsmStoredString::p_storage>;

};


template <> struct describe_node_t<SgAsmStoredString> {

  using node = SgAsmStoredString;

  using base = SgAsmGenericString;

  static constexpr char const * const name{"AsmStoredString"};

  static constexpr unsigned long variant{272};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmStoredString,SgAsmStringStorage*,&SgAsmStoredString::p_storage>>;

};


template <> struct node_from_variant_t<272> { using type = SgAsmStoredString; };


// Class: AsmStringStorage


template <> struct describe_field_t<SgAsmStringStorage,SgAsmGenericStrtab*,&SgAsmStringStorage::p_strtab> {

  using parent = SgAsmStringStorage;

  using field_type = SgAsmGenericStrtab*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"strtab"};

  static constexpr char const * const typestr{"SgAsmGenericStrtab*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStringStorage::p_strtab};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStringStorage, SgAsmGenericStrtab* SgAsmStringStorage::*, &SgAsmStringStorage::p_strtab>;

};


template <> struct describe_field_t<SgAsmStringStorage,std::string,&SgAsmStringStorage::p_string> {

  using parent = SgAsmStringStorage;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgAsmStringStorage::p_string};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStringStorage, std::string SgAsmStringStorage::*, &SgAsmStringStorage::p_string>;

};


template <> struct describe_field_t<SgAsmStringStorage,Rose::BinaryAnalysis::Address,&SgAsmStringStorage::p_offset> {

  using parent = SgAsmStringStorage;

  using field_type = Rose::BinaryAnalysis::Address;

  static constexpr size_t position{2};

  static constexpr char const * const name{"offset"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmStringStorage::p_offset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmStringStorage, Rose::BinaryAnalysis::Address SgAsmStringStorage::*, &SgAsmStringStorage::p_offset>;

};


template <> struct describe_node_t<SgAsmStringStorage> {

  using node = SgAsmStringStorage;

  using base = SgAsmExecutableFileFormat;

  static constexpr char const * const name{"AsmStringStorage"};

  static constexpr unsigned long variant{273};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmStringStorage,SgAsmGenericStrtab*,&SgAsmStringStorage::p_strtab>, describe_field_t<SgAsmStringStorage,std::string,&SgAsmStringStorage::p_string>, describe_field_t<SgAsmStringStorage,Rose::BinaryAnalysis::Address,&SgAsmStringStorage::p_offset>>;

};


template <> struct node_from_variant_t<273> { using type = SgAsmStringStorage; };


// Class: AsmType


template <> struct describe_node_t<SgAsmType> {

  using node = SgAsmType;

  using base = SgAsmNode;

  static constexpr char const * const name{"AsmType"};

  static constexpr unsigned long variant{274};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmScalarType, SgAsmVectorType, SgAsmVoidType>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<274> { using type = SgAsmType; };


// Class: AsmUnaryExpression


template <> struct describe_field_t<SgAsmUnaryExpression,SgAsmExpression*,&SgAsmUnaryExpression::p_operand> {

  using parent = SgAsmUnaryExpression;

  using field_type = SgAsmExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"operand"};

  static constexpr char const * const typestr{"SgAsmExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmUnaryExpression::p_operand};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmUnaryExpression, SgAsmExpression* SgAsmUnaryExpression::*, &SgAsmUnaryExpression::p_operand>;

};


template <> struct describe_node_t<SgAsmUnaryExpression> {

  using node = SgAsmUnaryExpression;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmUnaryExpression"};

  static constexpr unsigned long variant{275};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmUnaryMinus, SgAsmUnaryPlus, SgAsmUnaryRrx, SgAsmUnarySignedExtend, SgAsmUnaryTruncate, SgAsmUnaryUnsignedExtend>;

  using fields_t = mp::List<describe_field_t<SgAsmUnaryExpression,SgAsmExpression*,&SgAsmUnaryExpression::p_operand>>;

};


template <> struct node_from_variant_t<275> { using type = SgAsmUnaryExpression; };


// Class: AsmUnaryMinus


template <> struct describe_node_t<SgAsmUnaryMinus> {

  using node = SgAsmUnaryMinus;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnaryMinus"};

  static constexpr unsigned long variant{276};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<276> { using type = SgAsmUnaryMinus; };


// Class: AsmUnaryPlus


template <> struct describe_node_t<SgAsmUnaryPlus> {

  using node = SgAsmUnaryPlus;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnaryPlus"};

  static constexpr unsigned long variant{277};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<277> { using type = SgAsmUnaryPlus; };


// Class: AsmUnaryRrx


template <> struct describe_node_t<SgAsmUnaryRrx> {

  using node = SgAsmUnaryRrx;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnaryRrx"};

  static constexpr unsigned long variant{278};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<278> { using type = SgAsmUnaryRrx; };


// Class: AsmUnarySignedExtend


template <> struct describe_node_t<SgAsmUnarySignedExtend> {

  using node = SgAsmUnarySignedExtend;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnarySignedExtend"};

  static constexpr unsigned long variant{279};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<279> { using type = SgAsmUnarySignedExtend; };


// Class: AsmUnaryUnsignedExtend


template <> struct describe_node_t<SgAsmUnaryUnsignedExtend> {

  using node = SgAsmUnaryUnsignedExtend;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnaryUnsignedExtend"};

  static constexpr unsigned long variant{280};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<280> { using type = SgAsmUnaryUnsignedExtend; };


// Class: AsmUnaryTruncate


template <> struct describe_node_t<SgAsmUnaryTruncate> {

  using node = SgAsmUnaryTruncate;

  using base = SgAsmUnaryExpression;

  static constexpr char const * const name{"AsmUnaryTruncate"};

  static constexpr unsigned long variant{281};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<281> { using type = SgAsmUnaryTruncate; };


// Class: AsmValueExpression


template <> struct describe_field_t<SgAsmValueExpression,SgAsmValueExpression*,&SgAsmValueExpression::p_unfoldedExpression> {

  using parent = SgAsmValueExpression;

  using field_type = SgAsmValueExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"unfoldedExpression"};

  static constexpr char const * const typestr{"SgAsmValueExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAsmValueExpression::p_unfoldedExpression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmValueExpression, SgAsmValueExpression* SgAsmValueExpression::*, &SgAsmValueExpression::p_unfoldedExpression>;

};


template <> struct describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitOffset> {

  using parent = SgAsmValueExpression;

  using field_type = unsigned short;

  static constexpr size_t position{1};

  static constexpr char const * const name{"bitOffset"};

  static constexpr char const * const typestr{"unsigned short"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmValueExpression::p_bitOffset};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmValueExpression, unsigned short SgAsmValueExpression::*, &SgAsmValueExpression::p_bitOffset>;

};


template <> struct describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitSize> {

  using parent = SgAsmValueExpression;

  using field_type = unsigned short;

  static constexpr size_t position{2};

  static constexpr char const * const name{"bitSize"};

  static constexpr char const * const typestr{"unsigned short"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmValueExpression::p_bitSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmValueExpression, unsigned short SgAsmValueExpression::*, &SgAsmValueExpression::p_bitSize>;

};


template <> struct describe_field_t<SgAsmValueExpression,SgSymbol*,&SgAsmValueExpression::p_symbol> {

  using parent = SgAsmValueExpression;

  using field_type = SgSymbol*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"symbol"};

  static constexpr char const * const typestr{"SgSymbol*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmValueExpression::p_symbol};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmValueExpression, SgSymbol* SgAsmValueExpression::*, &SgAsmValueExpression::p_symbol>;

};


template <> struct describe_node_t<SgAsmValueExpression> {

  using node = SgAsmValueExpression;

  using base = SgAsmExpression;

  static constexpr char const * const name{"AsmValueExpression"};

  static constexpr unsigned long variant{282};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgAsmConstantExpression>;

  using fields_t = mp::List<describe_field_t<SgAsmValueExpression,SgAsmValueExpression*,&SgAsmValueExpression::p_unfoldedExpression>, describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitOffset>, describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitSize>, describe_field_t<SgAsmValueExpression,SgSymbol*,&SgAsmValueExpression::p_symbol>>;

};


template <> struct node_from_variant_t<282> { using type = SgAsmValueExpression; };


// Class: AsmVectorType


template <> struct describe_field_t<SgAsmVectorType,size_t,&SgAsmVectorType::p_nElmts> {

  using parent = SgAsmVectorType;

  using field_type = size_t;

  static constexpr size_t position{0};

  static constexpr char const * const name{"nElmts"};

  static constexpr char const * const typestr{"size_t"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmVectorType::p_nElmts};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmVectorType, size_t SgAsmVectorType::*, &SgAsmVectorType::p_nElmts>;

};


template <> struct describe_field_t<SgAsmVectorType,SgAsmType*,&SgAsmVectorType::p_elmtType> {

  using parent = SgAsmVectorType;

  using field_type = SgAsmType*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"elmtType"};

  static constexpr char const * const typestr{"SgAsmType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmVectorType::p_elmtType};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmVectorType, SgAsmType* SgAsmVectorType::*, &SgAsmVectorType::p_elmtType>;

};


template <> struct describe_node_t<SgAsmVectorType> {

  using node = SgAsmVectorType;

  using base = SgAsmType;

  static constexpr char const * const name{"AsmVectorType"};

  static constexpr unsigned long variant{283};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmVectorType,size_t,&SgAsmVectorType::p_nElmts>, describe_field_t<SgAsmVectorType,SgAsmType*,&SgAsmVectorType::p_elmtType>>;

};


template <> struct node_from_variant_t<283> { using type = SgAsmVectorType; };


// Class: AsmX86Instruction


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionKind,&SgAsmX86Instruction::p_kind> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86InstructionKind;

  static constexpr size_t position{0};

  static constexpr char const * const name{"kind"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionKind"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionKind SgAsmX86Instruction::*, &SgAsmX86Instruction::p_kind>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_baseSize> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86InstructionSize;

  static constexpr size_t position{1};

  static constexpr char const * const name{"baseSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_baseSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_baseSize>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_operandSize> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86InstructionSize;

  static constexpr size_t position{2};

  static constexpr char const * const name{"operandSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_operandSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_operandSize>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_addressSize> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86InstructionSize;

  static constexpr size_t position{3};

  static constexpr char const * const name{"addressSize"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_addressSize};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_addressSize>;

};


template <> struct describe_field_t<SgAsmX86Instruction,bool,&SgAsmX86Instruction::p_lockPrefix> {

  using parent = SgAsmX86Instruction;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"lockPrefix"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_lockPrefix};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, bool SgAsmX86Instruction::*, &SgAsmX86Instruction::p_lockPrefix>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86RepeatPrefix,&SgAsmX86Instruction::p_repeatPrefix> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86RepeatPrefix;

  static constexpr size_t position{5};

  static constexpr char const * const name{"repeatPrefix"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86RepeatPrefix"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_repeatPrefix};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86RepeatPrefix SgAsmX86Instruction::*, &SgAsmX86Instruction::p_repeatPrefix>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86BranchPrediction,&SgAsmX86Instruction::p_branchPrediction> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86BranchPrediction;

  static constexpr size_t position{6};

  static constexpr char const * const name{"branchPrediction"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86BranchPrediction"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_branchPrediction};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86BranchPrediction SgAsmX86Instruction::*, &SgAsmX86Instruction::p_branchPrediction>;

};


template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86SegmentRegister,&SgAsmX86Instruction::p_segmentOverride> {

  using parent = SgAsmX86Instruction;

  using field_type = Rose::BinaryAnalysis::X86SegmentRegister;

  static constexpr size_t position{7};

  static constexpr char const * const name{"segmentOverride"};

  static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86SegmentRegister"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_segmentOverride};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86SegmentRegister SgAsmX86Instruction::*, &SgAsmX86Instruction::p_segmentOverride>;

};


template <> struct describe_node_t<SgAsmX86Instruction> {

  using node = SgAsmX86Instruction;

  using base = SgAsmInstruction;

  static constexpr char const * const name{"AsmX86Instruction"};

  static constexpr unsigned long variant{284};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionKind,&SgAsmX86Instruction::p_kind>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_baseSize>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_operandSize>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_addressSize>, describe_field_t<SgAsmX86Instruction,bool,&SgAsmX86Instruction::p_lockPrefix>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86RepeatPrefix,&SgAsmX86Instruction::p_repeatPrefix>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86BranchPrediction,&SgAsmX86Instruction::p_branchPrediction>, describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86SegmentRegister,&SgAsmX86Instruction::p_segmentOverride>>;

};


template <> struct node_from_variant_t<284> { using type = SgAsmX86Instruction; };


// Class: AsmBinaryAddressSymbol


template <> struct describe_field_t<SgAsmBinaryAddressSymbol,SgName,&SgAsmBinaryAddressSymbol::p_address_name> {

  using parent = SgAsmBinaryAddressSymbol;

  using field_type = SgName;

  static constexpr size_t position{0};

  static constexpr char const * const name{"address_name"};

  static constexpr char const * const typestr{"SgName"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBinaryAddressSymbol::p_address_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBinaryAddressSymbol, SgName SgAsmBinaryAddressSymbol::*, &SgAsmBinaryAddressSymbol::p_address_name>;

};


template <> struct describe_field_t<SgAsmBinaryAddressSymbol,SgAsmInstruction*,&SgAsmBinaryAddressSymbol::p_address> {

  using parent = SgAsmBinaryAddressSymbol;

  using field_type = SgAsmInstruction*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"address"};

  static constexpr char const * const typestr{"SgAsmInstruction*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBinaryAddressSymbol::p_address};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBinaryAddressSymbol, SgAsmInstruction* SgAsmBinaryAddressSymbol::*, &SgAsmBinaryAddressSymbol::p_address>;

};


template <> struct describe_node_t<SgAsmBinaryAddressSymbol> {

  using node = SgAsmBinaryAddressSymbol;

  using base = SgSymbol;

  static constexpr char const * const name{"AsmBinaryAddressSymbol"};

  static constexpr unsigned long variant{285};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmBinaryAddressSymbol,SgName,&SgAsmBinaryAddressSymbol::p_address_name>, describe_field_t<SgAsmBinaryAddressSymbol,SgAsmInstruction*,&SgAsmBinaryAddressSymbol::p_address>>;

};


template <> struct node_from_variant_t<285> { using type = SgAsmBinaryAddressSymbol; };


// Class: AsmBinaryDataSymbol


template <> struct describe_field_t<SgAsmBinaryDataSymbol,SgName,&SgAsmBinaryDataSymbol::p_variable_name> {

  using parent = SgAsmBinaryDataSymbol;

  using field_type = SgName;

  static constexpr size_t position{0};

  static constexpr char const * const name{"variable_name"};

  static constexpr char const * const typestr{"SgName"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBinaryDataSymbol::p_variable_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBinaryDataSymbol, SgName SgAsmBinaryDataSymbol::*, &SgAsmBinaryDataSymbol::p_variable_name>;

};


template <> struct describe_field_t<SgAsmBinaryDataSymbol,SgAsmInstruction*,&SgAsmBinaryDataSymbol::p_address> {

  using parent = SgAsmBinaryDataSymbol;

  using field_type = SgAsmInstruction*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"address"};

  static constexpr char const * const typestr{"SgAsmInstruction*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAsmBinaryDataSymbol::p_address};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAsmBinaryDataSymbol, SgAsmInstruction* SgAsmBinaryDataSymbol::*, &SgAsmBinaryDataSymbol::p_address>;

};


template <> struct describe_node_t<SgAsmBinaryDataSymbol> {

  using node = SgAsmBinaryDataSymbol;

  using base = SgSymbol;

  static constexpr char const * const name{"AsmBinaryDataSymbol"};

  static constexpr unsigned long variant{286};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAsmBinaryDataSymbol,SgName,&SgAsmBinaryDataSymbol::p_variable_name>, describe_field_t<SgAsmBinaryDataSymbol,SgAsmInstruction*,&SgAsmBinaryDataSymbol::p_address>>;

};


template <> struct node_from_variant_t<286> { using type = SgAsmBinaryDataSymbol; };


// Class: AssertStmt


template <> struct describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_test> {

  using parent = SgAssertStmt;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"test"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssertStmt::p_test};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssertStmt, SgExpression* SgAssertStmt::*, &SgAssertStmt::p_test>;

};


template <> struct describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_exception_argument> {

  using parent = SgAssertStmt;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"exception_argument"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssertStmt::p_exception_argument};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssertStmt, SgExpression* SgAssertStmt::*, &SgAssertStmt::p_exception_argument>;

};


template <> struct describe_node_t<SgAssertStmt> {

  using node = SgAssertStmt;

  using base = SgStatement;

  static constexpr char const * const name{"AssertStmt"};

  static constexpr unsigned long variant{287};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_test>, describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_exception_argument>>;

};


template <> struct node_from_variant_t<287> { using type = SgAssertStmt; };


// Class: AssignInitializer


template <> struct describe_field_t<SgAssignInitializer,SgExpression*,&SgAssignInitializer::p_operand_i> {

  using parent = SgAssignInitializer;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"operand_i"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssignInitializer::p_operand_i};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssignInitializer, SgExpression* SgAssignInitializer::*, &SgAssignInitializer::p_operand_i>;

};


template <> struct describe_field_t<SgAssignInitializer,SgType*,&SgAssignInitializer::p_expression_type> {

  using parent = SgAssignInitializer;

  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{&SgAssignInitializer::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssignInitializer, SgType* SgAssignInitializer::*, &SgAssignInitializer::p_expression_type>;

};


template <> struct describe_node_t<SgAssignInitializer> {

  using node = SgAssignInitializer;

  using base = SgInitializer;

  static constexpr char const * const name{"AssignInitializer"};

  static constexpr unsigned long variant{288};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAssignInitializer,SgExpression*,&SgAssignInitializer::p_operand_i>, describe_field_t<SgAssignInitializer,SgType*,&SgAssignInitializer::p_expression_type>>;

};


template <> struct node_from_variant_t<288> { using type = SgAssignInitializer; };


// Class: AssignOp


template <> struct describe_node_t<SgAssignOp> {

  using node = SgAssignOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"AssignOp"};

  static constexpr unsigned long variant{289};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<289> { using type = SgAssignOp; };


// Class: AssignStatement


template <> struct describe_field_t<SgAssignStatement,SgLabelRefExp*,&SgAssignStatement::p_label> {

  using parent = SgAssignStatement;

  using field_type = SgLabelRefExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"label"};

  static constexpr char const * const typestr{"SgLabelRefExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAssignStatement::p_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssignStatement, SgLabelRefExp* SgAssignStatement::*, &SgAssignStatement::p_label>;

};


template <> struct describe_field_t<SgAssignStatement,SgExpression*,&SgAssignStatement::p_value> {

  using parent = SgAssignStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssignStatement::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssignStatement, SgExpression* SgAssignStatement::*, &SgAssignStatement::p_value>;

};


template <> struct describe_node_t<SgAssignStatement> {

  using node = SgAssignStatement;

  using base = SgStatement;

  static constexpr char const * const name{"AssignStatement"};

  static constexpr unsigned long variant{290};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAssignStatement,SgLabelRefExp*,&SgAssignStatement::p_label>, describe_field_t<SgAssignStatement,SgExpression*,&SgAssignStatement::p_value>>;

};


template <> struct node_from_variant_t<290> { using type = SgAssignStatement; };


// Class: AssignedGotoStatement


template <> struct describe_field_t<SgAssignedGotoStatement,SgExprListExp*,&SgAssignedGotoStatement::p_targets> {

  using parent = SgAssignedGotoStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"targets"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssignedGotoStatement::p_targets};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssignedGotoStatement, SgExprListExp* SgAssignedGotoStatement::*, &SgAssignedGotoStatement::p_targets>;

};


template <> struct describe_node_t<SgAssignedGotoStatement> {

  using node = SgAssignedGotoStatement;

  using base = SgStatement;

  static constexpr char const * const name{"AssignedGotoStatement"};

  static constexpr unsigned long variant{291};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAssignedGotoStatement,SgExprListExp*,&SgAssignedGotoStatement::p_targets>>;

};


template <> struct node_from_variant_t<291> { using type = SgAssignedGotoStatement; };


// Class: AssociateStatement


template <> struct describe_field_t<SgAssociateStatement,SgDeclarationStatementPtrList,&SgAssociateStatement::p_associates> {

  using parent = SgAssociateStatement;

  using field_type = SgDeclarationStatementPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"associates"};

  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAssociateStatement::p_associates};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssociateStatement, SgDeclarationStatementPtrList SgAssociateStatement::*, &SgAssociateStatement::p_associates>;

};


template <> struct describe_field_t<SgAssociateStatement,SgBasicBlock*,&SgAssociateStatement::p_body> {

  using parent = SgAssociateStatement;

  using field_type = SgBasicBlock*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgBasicBlock*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAssociateStatement::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAssociateStatement, SgBasicBlock* SgAssociateStatement::*, &SgAssociateStatement::p_body>;

};


template <> struct describe_node_t<SgAssociateStatement> {

  using node = SgAssociateStatement;

  using base = SgScopeStatement;

  static constexpr char const * const name{"AssociateStatement"};

  static constexpr unsigned long variant{292};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAssociateStatement,SgDeclarationStatementPtrList,&SgAssociateStatement::p_associates>, describe_field_t<SgAssociateStatement,SgBasicBlock*,&SgAssociateStatement::p_body>>;

};


template <> struct node_from_variant_t<292> { using type = SgAssociateStatement; };


// Class: AsteriskShapeExp


template <> struct describe_node_t<SgAsteriskShapeExp> {

  using node = SgAsteriskShapeExp;

  using base = SgExpression;

  static constexpr char const * const name{"AsteriskShapeExp"};

  static constexpr unsigned long variant{293};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<293> { using type = SgAsteriskShapeExp; };


// Class: AtOp


template <> struct describe_node_t<SgAtOp> {

  using node = SgAtOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"AtOp"};

  static constexpr unsigned long variant{294};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<294> { using type = SgAtOp; };


// Class: Attribute


template <> struct describe_field_t<SgAttribute,std::string,&SgAttribute::p_name> {

  using parent = SgAttribute;

  using field_type = std::string;

  static constexpr size_t position{0};

  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{&SgAttribute::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttribute, std::string SgAttribute::*, &SgAttribute::p_name>;

};


template <> struct describe_node_t<SgAttribute> {

  using node = SgAttribute;

  using base = SgSupport;

  static constexpr char const * const name{"Attribute"};

  static constexpr unsigned long variant{295};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgPragma, SgBitAttribute>;

  using fields_t = mp::List<describe_field_t<SgAttribute,std::string,&SgAttribute::p_name>>;

};


template <> struct node_from_variant_t<295> { using type = SgAttribute; };


// Class: AttributeSpecificationStatement


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgStringList,&SgAttributeSpecificationStatement::p_name_list> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgStringList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"name_list"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_name_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgStringList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_name_list>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgAttributeSpecificationStatement::attribute_spec_enum,&SgAttributeSpecificationStatement::p_attribute_kind> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgAttributeSpecificationStatement::attribute_spec_enum;

  static constexpr size_t position{1};

  static constexpr char const * const name{"attribute_kind"};

  static constexpr char const * const typestr{"SgAttributeSpecificationStatement::attribute_spec_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_attribute_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgAttributeSpecificationStatement::attribute_spec_enum SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_attribute_kind>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,int,&SgAttributeSpecificationStatement::p_intent> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = int;

  static constexpr size_t position{2};

  static constexpr char const * const name{"intent"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_intent};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, int SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_intent>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_parameter_list> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"parameter_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_parameter_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgExprListExp* SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_parameter_list>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgDataStatementGroupPtrList,&SgAttributeSpecificationStatement::p_data_statement_group_list> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgDataStatementGroupPtrList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"data_statement_group_list"};

  static constexpr char const * const typestr{"SgDataStatementGroupPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_data_statement_group_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgDataStatementGroupPtrList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_data_statement_group_list>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_bind_list> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"bind_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_bind_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgExprListExp* SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_bind_list>;

};


template <> struct describe_field_t<SgAttributeSpecificationStatement,SgDimensionObjectPtrList,&SgAttributeSpecificationStatement::p_dimension_object_list> {

  using parent = SgAttributeSpecificationStatement;

  using field_type = SgDimensionObjectPtrList;

  static constexpr size_t position{6};

  static constexpr char const * const name{"dimension_object_list"};

  static constexpr char const * const typestr{"SgDimensionObjectPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_dimension_object_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAttributeSpecificationStatement, SgDimensionObjectPtrList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_dimension_object_list>;

};


template <> struct describe_node_t<SgAttributeSpecificationStatement> {

  using node = SgAttributeSpecificationStatement;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"AttributeSpecificationStatement"};

  static constexpr unsigned long variant{296};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAttributeSpecificationStatement,SgStringList,&SgAttributeSpecificationStatement::p_name_list>, describe_field_t<SgAttributeSpecificationStatement,SgAttributeSpecificationStatement::attribute_spec_enum,&SgAttributeSpecificationStatement::p_attribute_kind>, describe_field_t<SgAttributeSpecificationStatement,int,&SgAttributeSpecificationStatement::p_intent>, describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_parameter_list>, describe_field_t<SgAttributeSpecificationStatement,SgDataStatementGroupPtrList,&SgAttributeSpecificationStatement::p_data_statement_group_list>, describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_bind_list>, describe_field_t<SgAttributeSpecificationStatement,SgDimensionObjectPtrList,&SgAttributeSpecificationStatement::p_dimension_object_list>>;

};


template <> struct node_from_variant_t<296> { using type = SgAttributeSpecificationStatement; };


// Class: AutoType


template <> struct describe_node_t<SgAutoType> {

  using node = SgAutoType;

  using base = SgType;

  static constexpr char const * const name{"AutoType"};

  static constexpr unsigned long variant{297};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<297> { using type = SgAutoType; };


// Class: AwaitExpression


template <> struct describe_field_t<SgAwaitExpression,SgExpression*,&SgAwaitExpression::p_value> {

  using parent = SgAwaitExpression;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgAwaitExpression::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgAwaitExpression, SgExpression* SgAwaitExpression::*, &SgAwaitExpression::p_value>;

};


template <> struct describe_node_t<SgAwaitExpression> {

  using node = SgAwaitExpression;

  using base = SgExpression;

  static constexpr char const * const name{"AwaitExpression"};

  static constexpr unsigned long variant{298};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgAwaitExpression,SgExpression*,&SgAwaitExpression::p_value>>;

};


template <> struct node_from_variant_t<298> { using type = SgAwaitExpression; };


// Class: BackspaceStatement


template <> struct describe_node_t<SgBackspaceStatement> {

  using node = SgBackspaceStatement;

  using base = SgIOStatement;

  static constexpr char const * const name{"BackspaceStatement"};

  static constexpr unsigned long variant{299};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<299> { using type = SgBackspaceStatement; };


// Class: BaseClass


template <> struct describe_field_t<SgBaseClass,SgClassDeclaration*,&SgBaseClass::p_base_class> {

  using parent = SgBaseClass;

  using field_type = SgClassDeclaration*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"base_class"};

  static constexpr char const * const typestr{"SgClassDeclaration*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBaseClass::p_base_class};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, SgClassDeclaration* SgBaseClass::*, &SgBaseClass::p_base_class>;

};


template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_isDirectBaseClass> {

  using parent = SgBaseClass;

  using field_type = bool;

  static constexpr size_t position{1};

  static constexpr char const * const name{"isDirectBaseClass"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClass::p_isDirectBaseClass};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_isDirectBaseClass>;

};


template <> struct describe_field_t<SgBaseClass,SgBaseClassModifier*,&SgBaseClass::p_baseClassModifier> {

  using parent = SgBaseClass;

  using field_type = SgBaseClassModifier*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"baseClassModifier"};

  static constexpr char const * const typestr{"SgBaseClassModifier*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClass::p_baseClassModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, SgBaseClassModifier* SgBaseClass::*, &SgBaseClass::p_baseClassModifier>;

};


template <> struct describe_field_t<SgBaseClass,int,&SgBaseClass::p_name_qualification_length> {

  using parent = SgBaseClass;

  using field_type = int;

  static constexpr size_t position{3};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClass::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, int SgBaseClass::*, &SgBaseClass::p_name_qualification_length>;

};


template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_type_elaboration_required> {

  using parent = SgBaseClass;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClass::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_global_qualification_required> {

  using parent = SgBaseClass;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClass::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_global_qualification_required>;

};


template <> struct describe_node_t<SgBaseClass> {

  using node = SgBaseClass;

  using base = SgSupport;

  static constexpr char const * const name{"BaseClass"};

  static constexpr unsigned long variant{300};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgExpBaseClass, SgNonrealBaseClass>;

  using fields_t = mp::List<describe_field_t<SgBaseClass,SgClassDeclaration*,&SgBaseClass::p_base_class>, describe_field_t<SgBaseClass,bool,&SgBaseClass::p_isDirectBaseClass>, describe_field_t<SgBaseClass,SgBaseClassModifier*,&SgBaseClass::p_baseClassModifier>, describe_field_t<SgBaseClass,int,&SgBaseClass::p_name_qualification_length>, describe_field_t<SgBaseClass,bool,&SgBaseClass::p_type_elaboration_required>, describe_field_t<SgBaseClass,bool,&SgBaseClass::p_global_qualification_required>>;

};


template <> struct node_from_variant_t<300> { using type = SgBaseClass; };


// Class: ExpBaseClass


template <> struct describe_field_t<SgExpBaseClass,SgExpression*,&SgExpBaseClass::p_base_class_exp> {

  using parent = SgExpBaseClass;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"base_class_exp"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExpBaseClass::p_base_class_exp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExpBaseClass, SgExpression* SgExpBaseClass::*, &SgExpBaseClass::p_base_class_exp>;

};


template <> struct describe_node_t<SgExpBaseClass> {

  using node = SgExpBaseClass;

  using base = SgBaseClass;

  static constexpr char const * const name{"ExpBaseClass"};

  static constexpr unsigned long variant{301};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgExpBaseClass,SgExpression*,&SgExpBaseClass::p_base_class_exp>>;

};


template <> struct node_from_variant_t<301> { using type = SgExpBaseClass; };


// Class: BaseClassModifier


template <> struct describe_field_t<SgBaseClassModifier,SgBaseClassModifier::baseclass_modifier_enum,&SgBaseClassModifier::p_modifier> {

  using parent = SgBaseClassModifier;

  using field_type = SgBaseClassModifier::baseclass_modifier_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"modifier"};

  static constexpr char const * const typestr{"SgBaseClassModifier::baseclass_modifier_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClassModifier::p_modifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClassModifier, SgBaseClassModifier::baseclass_modifier_enum SgBaseClassModifier::*, &SgBaseClassModifier::p_modifier>;

};


template <> struct describe_field_t<SgBaseClassModifier,SgAccessModifier,&SgBaseClassModifier::p_accessModifier> {

  using parent = SgBaseClassModifier;

  using field_type = SgAccessModifier;

  static constexpr size_t position{1};

  static constexpr char const * const name{"accessModifier"};

  static constexpr char const * const typestr{"SgAccessModifier"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBaseClassModifier::p_accessModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBaseClassModifier, SgAccessModifier SgBaseClassModifier::*, &SgBaseClassModifier::p_accessModifier>;

};


template <> struct describe_node_t<SgBaseClassModifier> {

  using node = SgBaseClassModifier;

  using base = SgModifier;

  static constexpr char const * const name{"BaseClassModifier"};

  static constexpr unsigned long variant{302};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBaseClassModifier,SgBaseClassModifier::baseclass_modifier_enum,&SgBaseClassModifier::p_modifier>, describe_field_t<SgBaseClassModifier,SgAccessModifier,&SgBaseClassModifier::p_accessModifier>>;

};


template <> struct node_from_variant_t<302> { using type = SgBaseClassModifier; };


// Class: BasicBlock


template <> struct describe_field_t<SgBasicBlock,SgStatementPtrList,&SgBasicBlock::p_statements> {

  using parent = SgBasicBlock;

  using field_type = SgStatementPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"statements"};

  static constexpr char const * const typestr{"SgStatementPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBasicBlock::p_statements};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBasicBlock, SgStatementPtrList SgBasicBlock::*, &SgBasicBlock::p_statements>;

};


template <> struct describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_asm_function_body> {

  using parent = SgBasicBlock;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"asm_function_body"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBasicBlock::p_asm_function_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBasicBlock, std::string SgBasicBlock::*, &SgBasicBlock::p_asm_function_body>;

};


template <> struct describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_string_label> {

  using parent = SgBasicBlock;

  using field_type = std::string;

  static constexpr size_t position{2};

  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{&SgBasicBlock::p_string_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBasicBlock, std::string SgBasicBlock::*, &SgBasicBlock::p_string_label>;

};


template <> struct describe_node_t<SgBasicBlock> {

  using node = SgBasicBlock;

  using base = SgScopeStatement;

  static constexpr char const * const name{"BasicBlock"};

  static constexpr unsigned long variant{303};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBasicBlock,SgStatementPtrList,&SgBasicBlock::p_statements>, describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_asm_function_body>, describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_string_label>>;

};


template <> struct node_from_variant_t<303> { using type = SgBasicBlock; };


// Class: BidirectionalGraph


template <> struct describe_node_t<SgBidirectionalGraph> {

  using node = SgBidirectionalGraph;

  using base = SgIncidenceDirectedGraph;

  static constexpr char const * const name{"BidirectionalGraph"};

  static constexpr unsigned long variant{304};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgStringKeyedBidirectionalGraph, SgIntKeyedBidirectionalGraph>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<304> { using type = SgBidirectionalGraph; };


// Class: BinaryComposite


template <> struct describe_field_t<SgBinaryComposite,SgAsmGenericFileList*,&SgBinaryComposite::p_genericFileList> {

  using parent = SgBinaryComposite;

  using field_type = SgAsmGenericFileList*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"genericFileList"};

  static constexpr char const * const typestr{"SgAsmGenericFileList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBinaryComposite::p_genericFileList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryComposite, SgAsmGenericFileList* SgBinaryComposite::*, &SgBinaryComposite::p_genericFileList>;

};


template <> struct describe_field_t<SgBinaryComposite,SgAsmInterpretationList*,&SgBinaryComposite::p_interpretations> {

  using parent = SgBinaryComposite;

  using field_type = SgAsmInterpretationList*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"interpretations"};

  static constexpr char const * const typestr{"SgAsmInterpretationList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBinaryComposite::p_interpretations};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryComposite, SgAsmInterpretationList* SgBinaryComposite::*, &SgBinaryComposite::p_interpretations>;

};


template <> struct describe_node_t<SgBinaryComposite> {

  using node = SgBinaryComposite;

  using base = SgFile;

  static constexpr char const * const name{"BinaryComposite"};

  static constexpr unsigned long variant{305};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgJvmComposite>;

  using fields_t = mp::List<describe_field_t<SgBinaryComposite,SgAsmGenericFileList*,&SgBinaryComposite::p_genericFileList>, describe_field_t<SgBinaryComposite,SgAsmInterpretationList*,&SgBinaryComposite::p_interpretations>>;

};


template <> struct node_from_variant_t<305> { using type = SgBinaryComposite; };


// Class: BinaryOp


template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_lhs_operand_i> {

  using parent = SgBinaryOp;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"lhs_operand_i"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBinaryOp::p_lhs_operand_i};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_lhs_operand_i>;

};


template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_rhs_operand_i> {

  using parent = SgBinaryOp;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"rhs_operand_i"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgBinaryOp::p_rhs_operand_i};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_rhs_operand_i>;

};


template <> struct describe_field_t<SgBinaryOp,SgType*,&SgBinaryOp::p_expression_type> {

  using parent = SgBinaryOp;

  using field_type = SgType*;

  static constexpr size_t position{2};

  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{&SgBinaryOp::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryOp, SgType* SgBinaryOp::*, &SgBinaryOp::p_expression_type>;

};


template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_originalExpressionTree> {

  using parent = SgBinaryOp;

  using field_type = SgExpression*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"originalExpressionTree"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBinaryOp::p_originalExpressionTree};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_originalExpressionTree>;

};


template <> struct describe_node_t<SgBinaryOp> {

  using node = SgBinaryOp;

  using base = SgExpression;

  static constexpr char const * const name{"BinaryOp"};

  static constexpr unsigned long variant{306};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgArrowExp, SgDotExp, SgDotStarOp, SgArrowStarOp, SgEqualityOp, SgLessThanOp, SgGreaterThanOp, SgNotEqualOp, SgLessOrEqualOp, SgGreaterOrEqualOp, SgAddOp, SgSubtractOp, SgMultiplyOp, SgDivideOp, SgIntegerDivideOp, SgModOp, SgAndOp, SgOrOp, SgBitXorOp, SgBitAndOp, SgBitOrOp, SgBitEqvOp, SgCommaOpExp, SgLshiftOp, SgRshiftOp, SgPntrArrRefExp, SgScopeOp, SgAssignOp, SgExponentiationOp, SgJavaUnsignedRshiftOp, SgConcatenationOp, SgPointerAssignOp, SgUserDefinedBinaryOp, SgCompoundAssignOp, SgMembershipOp, SgSpaceshipOp, SgNonMembershipOp, SgIsOp, SgIsNotOp, SgDotDotExp, SgElementwiseOp, SgPowerOp, SgLeftDivideOp, SgRemOp, SgReplicationOp, SgAtOp>;

  using fields_t = mp::List<describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_lhs_operand_i>, describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_rhs_operand_i>, describe_field_t<SgBinaryOp,SgType*,&SgBinaryOp::p_expression_type>, describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_originalExpressionTree>>;

};


template <> struct node_from_variant_t<306> { using type = SgBinaryOp; };


// Class: BitAndOp


template <> struct describe_node_t<SgBitAndOp> {

  using node = SgBitAndOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"BitAndOp"};

  static constexpr unsigned long variant{307};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<307> { using type = SgBitAndOp; };


// Class: BitAttribute


template <> struct describe_field_t<SgBitAttribute,unsigned long int,&SgBitAttribute::p_bitflag> {

  using parent = SgBitAttribute;

  using field_type = unsigned long int;

  static constexpr size_t position{0};

  static constexpr char const * const name{"bitflag"};

  static constexpr char const * const typestr{"unsigned long int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBitAttribute::p_bitflag};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBitAttribute, unsigned long int SgBitAttribute::*, &SgBitAttribute::p_bitflag>;

};


template <> struct describe_node_t<SgBitAttribute> {

  using node = SgBitAttribute;

  using base = SgAttribute;

  static constexpr char const * const name{"BitAttribute"};

  static constexpr unsigned long variant{308};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgFuncDecl_attr, SgClassDecl_attr>;

  using fields_t = mp::List<describe_field_t<SgBitAttribute,unsigned long int,&SgBitAttribute::p_bitflag>>;

};


template <> struct node_from_variant_t<308> { using type = SgBitAttribute; };


// Class: BitComplementOp


template <> struct describe_node_t<SgBitComplementOp> {

  using node = SgBitComplementOp;

  using base = SgUnaryOp;

  static constexpr char const * const name{"BitComplementOp"};

  static constexpr unsigned long variant{309};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<309> { using type = SgBitComplementOp; };


// Class: BitEqvOp


template <> struct describe_node_t<SgBitEqvOp> {

  using node = SgBitEqvOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"BitEqvOp"};

  static constexpr unsigned long variant{310};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<310> { using type = SgBitEqvOp; };


// Class: BitOrOp


template <> struct describe_node_t<SgBitOrOp> {

  using node = SgBitOrOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"BitOrOp"};

  static constexpr unsigned long variant{311};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<311> { using type = SgBitOrOp; };


// Class: BitXorOp


template <> struct describe_node_t<SgBitXorOp> {

  using node = SgBitXorOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"BitXorOp"};

  static constexpr unsigned long variant{312};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<312> { using type = SgBitXorOp; };


// Class: BlockDataStatement


template <> struct describe_field_t<SgBlockDataStatement,SgBasicBlock*,&SgBlockDataStatement::p_body> {

  using parent = SgBlockDataStatement;

  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{false};

  static constexpr auto mbr_ptr{&SgBlockDataStatement::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBlockDataStatement, SgBasicBlock* SgBlockDataStatement::*, &SgBlockDataStatement::p_body>;

};


template <> struct describe_node_t<SgBlockDataStatement> {

  using node = SgBlockDataStatement;

  using base = SgScopeStatement;

  static constexpr char const * const name{"BlockDataStatement"};

  static constexpr unsigned long variant{313};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBlockDataStatement,SgBasicBlock*,&SgBlockDataStatement::p_body>>;

};


template <> struct node_from_variant_t<313> { using type = SgBlockDataStatement; };


// Class: BoolValExp


template <> struct describe_field_t<SgBoolValExp,int,&SgBoolValExp::p_value> {

  using parent = SgBoolValExp;

  using field_type = int;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBoolValExp::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBoolValExp, int SgBoolValExp::*, &SgBoolValExp::p_value>;

};


template <> struct describe_node_t<SgBoolValExp> {

  using node = SgBoolValExp;

  using base = SgValueExp;

  static constexpr char const * const name{"BoolValExp"};

  static constexpr unsigned long variant{314};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBoolValExp,int,&SgBoolValExp::p_value>>;

};


template <> struct node_from_variant_t<314> { using type = SgBoolValExp; };


// Class: BreakStmt


template <> struct describe_field_t<SgBreakStmt,std::string,&SgBreakStmt::p_do_string_label> {

  using parent = SgBreakStmt;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"do_string_label"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgBreakStmt::p_do_string_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBreakStmt, std::string SgBreakStmt::*, &SgBreakStmt::p_do_string_label>;

};


template <> struct describe_node_t<SgBreakStmt> {

  using node = SgBreakStmt;

  using base = SgStatement;

  static constexpr char const * const name{"BreakStmt"};

  static constexpr unsigned long variant{315};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBreakStmt,std::string,&SgBreakStmt::p_do_string_label>>;

};


template <> struct node_from_variant_t<315> { using type = SgBreakStmt; };


// Class: BracedInitializer


template <> struct describe_field_t<SgBracedInitializer,SgExprListExp*,&SgBracedInitializer::p_initializers> {

  using parent = SgBracedInitializer;

  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{&SgBracedInitializer::p_initializers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBracedInitializer, SgExprListExp* SgBracedInitializer::*, &SgBracedInitializer::p_initializers>;

};


template <> struct describe_field_t<SgBracedInitializer,SgType*,&SgBracedInitializer::p_expression_type> {

  using parent = SgBracedInitializer;

  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{&SgBracedInitializer::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgBracedInitializer, SgType* SgBracedInitializer::*, &SgBracedInitializer::p_expression_type>;

};


template <> struct describe_node_t<SgBracedInitializer> {

  using node = SgBracedInitializer;

  using base = SgInitializer;

  static constexpr char const * const name{"BracedInitializer"};

  static constexpr unsigned long variant{316};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgBracedInitializer,SgExprListExp*,&SgBracedInitializer::p_initializers>, describe_field_t<SgBracedInitializer,SgType*,&SgBracedInitializer::p_expression_type>>;

};


template <> struct node_from_variant_t<316> { using type = SgBracedInitializer; };


// Class: C_PreprocessorDirectiveStatement


template <> struct describe_field_t<SgC_PreprocessorDirectiveStatement,std::string,&SgC_PreprocessorDirectiveStatement::p_directiveString> {

  using parent = SgC_PreprocessorDirectiveStatement;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"directiveString"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgC_PreprocessorDirectiveStatement::p_directiveString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgC_PreprocessorDirectiveStatement, std::string SgC_PreprocessorDirectiveStatement::*, &SgC_PreprocessorDirectiveStatement::p_directiveString>;

};


template <> struct describe_node_t<SgC_PreprocessorDirectiveStatement> {

  using node = SgC_PreprocessorDirectiveStatement;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"C_PreprocessorDirectiveStatement"};

  static constexpr unsigned long variant{317};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgIncludeDirectiveStatement, SgDefineDirectiveStatement, SgUndefDirectiveStatement, SgIfdefDirectiveStatement, SgIfndefDirectiveStatement, SgIfDirectiveStatement, SgDeadIfDirectiveStatement, SgElseDirectiveStatement, SgElseifDirectiveStatement, SgEndifDirectiveStatement, SgLineDirectiveStatement, SgWarningDirectiveStatement, SgErrorDirectiveStatement, SgEmptyDirectiveStatement, SgIncludeNextDirectiveStatement, SgIdentDirectiveStatement, SgLinemarkerDirectiveStatement>;

  using fields_t = mp::List<describe_field_t<SgC_PreprocessorDirectiveStatement,std::string,&SgC_PreprocessorDirectiveStatement::p_directiveString>>;

};


template <> struct node_from_variant_t<317> { using type = SgC_PreprocessorDirectiveStatement; };


// Class: CaseOptionStmt


template <> struct describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key> {

  using parent = SgCaseOptionStmt;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"key"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_key};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCaseOptionStmt, SgExpression* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_key>;

};


template <> struct describe_field_t<SgCaseOptionStmt,SgStatement*,&SgCaseOptionStmt::p_body> {

  using parent = SgCaseOptionStmt;

  using field_type = SgStatement*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCaseOptionStmt, SgStatement* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_body>;

};


template <> struct describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key_range_end> {

  using parent = SgCaseOptionStmt;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"key_range_end"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_key_range_end};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCaseOptionStmt, SgExpression* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_key_range_end>;

};


template <> struct describe_field_t<SgCaseOptionStmt,std::string,&SgCaseOptionStmt::p_case_construct_name> {

  using parent = SgCaseOptionStmt;

  using field_type = std::string;

  static constexpr size_t position{3};

  static constexpr char const * const name{"case_construct_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_case_construct_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCaseOptionStmt, std::string SgCaseOptionStmt::*, &SgCaseOptionStmt::p_case_construct_name>;

};


template <> struct describe_field_t<SgCaseOptionStmt,bool,&SgCaseOptionStmt::p_has_fall_through> {

  using parent = SgCaseOptionStmt;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"has_fall_through"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_has_fall_through};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCaseOptionStmt, bool SgCaseOptionStmt::*, &SgCaseOptionStmt::p_has_fall_through>;

};


template <> struct describe_node_t<SgCaseOptionStmt> {

  using node = SgCaseOptionStmt;

  using base = SgStatement;

  static constexpr char const * const name{"CaseOptionStmt"};

  static constexpr unsigned long variant{318};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key>, describe_field_t<SgCaseOptionStmt,SgStatement*,&SgCaseOptionStmt::p_body>, describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key_range_end>, describe_field_t<SgCaseOptionStmt,std::string,&SgCaseOptionStmt::p_case_construct_name>, describe_field_t<SgCaseOptionStmt,bool,&SgCaseOptionStmt::p_has_fall_through>>;

};


template <> struct node_from_variant_t<318> { using type = SgCaseOptionStmt; };


// Class: CastExp


template <> struct describe_field_t<SgCastExp,SgCastExp::cast_type_enum,&SgCastExp::p_cast_type> {

  using parent = SgCastExp;

  using field_type = SgCastExp::cast_type_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"cast_type"};

  static constexpr char const * const typestr{"SgCastExp::cast_type_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_cast_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, SgCastExp::cast_type_enum SgCastExp::*, &SgCastExp::p_cast_type>;

};


template <> struct describe_field_t<SgCastExp,SgExpression*,&SgCastExp::p_originalExpressionTree> {

  using parent = SgCastExp;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"originalExpressionTree"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_originalExpressionTree};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, SgExpression* SgCastExp::*, &SgCastExp::p_originalExpressionTree>;

};


template <> struct describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_length> {

  using parent = SgCastExp;

  using field_type = int;

  static constexpr size_t position{2};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, int SgCastExp::*, &SgCastExp::p_name_qualification_length>;

};


template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_required> {

  using parent = SgCastExp;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_required> {

  using parent = SgCastExp;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_global_qualification_required>;

};


template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_castContainsBaseTypeDefiningDeclaration> {

  using parent = SgCastExp;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"castContainsBaseTypeDefiningDeclaration"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_castContainsBaseTypeDefiningDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_castContainsBaseTypeDefiningDeclaration>;

};


template <> struct describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_for_pointer_to_member_class_length> {

  using parent = SgCastExp;

  using field_type = int;

  static constexpr size_t position{6};

  static constexpr char const * const name{"name_qualification_for_pointer_to_member_class_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_name_qualification_for_pointer_to_member_class_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, int SgCastExp::*, &SgCastExp::p_name_qualification_for_pointer_to_member_class_length>;

};


template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_for_pointer_to_member_class_required> {

  using parent = SgCastExp;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"type_elaboration_for_pointer_to_member_class_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_type_elaboration_for_pointer_to_member_class_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_type_elaboration_for_pointer_to_member_class_required>;

};


template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_for_pointer_to_member_class_required> {

  using parent = SgCastExp;

  using field_type = bool;

  static constexpr size_t position{8};

  static constexpr char const * const name{"global_qualification_for_pointer_to_member_class_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCastExp::p_global_qualification_for_pointer_to_member_class_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_global_qualification_for_pointer_to_member_class_required>;

};


template <> struct describe_node_t<SgCastExp> {

  using node = SgCastExp;

  using base = SgUnaryOp;

  static constexpr char const * const name{"CastExp"};

  static constexpr unsigned long variant{319};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCastExp,SgCastExp::cast_type_enum,&SgCastExp::p_cast_type>, describe_field_t<SgCastExp,SgExpression*,&SgCastExp::p_originalExpressionTree>, describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_length>, describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_required>, describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_required>, describe_field_t<SgCastExp,bool,&SgCastExp::p_castContainsBaseTypeDefiningDeclaration>, describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_for_pointer_to_member_class_length>, describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_for_pointer_to_member_class_required>, describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_for_pointer_to_member_class_required>>;

};


template <> struct node_from_variant_t<319> { using type = SgCastExp; };


// Class: CatchOptionStmt


template <> struct describe_field_t<SgCatchOptionStmt,SgVariableDeclaration*,&SgCatchOptionStmt::p_condition> {

  using parent = SgCatchOptionStmt;

  using field_type = SgVariableDeclaration*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"condition"};

  static constexpr char const * const typestr{"SgVariableDeclaration*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_condition};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCatchOptionStmt, SgVariableDeclaration* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_condition>;

};


template <> struct describe_field_t<SgCatchOptionStmt,SgStatement*,&SgCatchOptionStmt::p_body> {

  using parent = SgCatchOptionStmt;

  using field_type = SgStatement*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCatchOptionStmt, SgStatement* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_body>;

};


template <> struct describe_field_t<SgCatchOptionStmt,SgTryStmt*,&SgCatchOptionStmt::p_trystmt> {

  using parent = SgCatchOptionStmt;

  using field_type = SgTryStmt*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"trystmt"};

  static constexpr char const * const typestr{"SgTryStmt*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_trystmt};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCatchOptionStmt, SgTryStmt* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_trystmt>;

};


template <> struct describe_node_t<SgCatchOptionStmt> {

  using node = SgCatchOptionStmt;

  using base = SgScopeStatement;

  static constexpr char const * const name{"CatchOptionStmt"};

  static constexpr unsigned long variant{320};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCatchOptionStmt,SgVariableDeclaration*,&SgCatchOptionStmt::p_condition>, describe_field_t<SgCatchOptionStmt,SgStatement*,&SgCatchOptionStmt::p_body>, describe_field_t<SgCatchOptionStmt,SgTryStmt*,&SgCatchOptionStmt::p_trystmt>>;

};


template <> struct node_from_variant_t<320> { using type = SgCatchOptionStmt; };


// Class: CatchStatementSeq


template <> struct describe_field_t<SgCatchStatementSeq,SgStatementPtrList,&SgCatchStatementSeq::p_catch_statement_seq> {

  using parent = SgCatchStatementSeq;

  using field_type = SgStatementPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"catch_statement_seq"};

  static constexpr char const * const typestr{"SgStatementPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCatchStatementSeq::p_catch_statement_seq};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCatchStatementSeq, SgStatementPtrList SgCatchStatementSeq::*, &SgCatchStatementSeq::p_catch_statement_seq>;

};


template <> struct describe_node_t<SgCatchStatementSeq> {

  using node = SgCatchStatementSeq;

  using base = SgStatement;

  static constexpr char const * const name{"CatchStatementSeq"};

  static constexpr unsigned long variant{321};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCatchStatementSeq,SgStatementPtrList,&SgCatchStatementSeq::p_catch_statement_seq>>;

};


template <> struct node_from_variant_t<321> { using type = SgCatchStatementSeq; };


// Class: CharVal


template <> struct describe_field_t<SgCharVal,char,&SgCharVal::p_value> {

  using parent = SgCharVal;

  using field_type = char;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"char"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCharVal::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCharVal, char SgCharVal::*, &SgCharVal::p_value>;

};


template <> struct describe_field_t<SgCharVal,std::string,&SgCharVal::p_valueString> {

  using parent = SgCharVal;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgCharVal::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCharVal, std::string SgCharVal::*, &SgCharVal::p_valueString>;

};


template <> struct describe_node_t<SgCharVal> {

  using node = SgCharVal;

  using base = SgValueExp;

  static constexpr char const * const name{"CharVal"};

  static constexpr unsigned long variant{322};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCharVal,char,&SgCharVal::p_value>, describe_field_t<SgCharVal,std::string,&SgCharVal::p_valueString>>;

};


template <> struct node_from_variant_t<322> { using type = SgCharVal; };


// Class: Char16Val


template <> struct describe_field_t<SgChar16Val,unsigned short,&SgChar16Val::p_valueUL> {

  using parent = SgChar16Val;

  using field_type = unsigned short;

  static constexpr size_t position{0};

  static constexpr char const * const name{"valueUL"};

  static constexpr char const * const typestr{"unsigned short"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgChar16Val::p_valueUL};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgChar16Val, unsigned short SgChar16Val::*, &SgChar16Val::p_valueUL>;

};


template <> struct describe_field_t<SgChar16Val,std::string,&SgChar16Val::p_valueString> {

  using parent = SgChar16Val;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgChar16Val::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgChar16Val, std::string SgChar16Val::*, &SgChar16Val::p_valueString>;

};


template <> struct describe_node_t<SgChar16Val> {

  using node = SgChar16Val;

  using base = SgValueExp;

  static constexpr char const * const name{"Char16Val"};

  static constexpr unsigned long variant{323};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgChar16Val,unsigned short,&SgChar16Val::p_valueUL>, describe_field_t<SgChar16Val,std::string,&SgChar16Val::p_valueString>>;

};


template <> struct node_from_variant_t<323> { using type = SgChar16Val; };


// Class: Char32Val


template <> struct describe_field_t<SgChar32Val,unsigned int,&SgChar32Val::p_valueUL> {

  using parent = SgChar32Val;

  using field_type = unsigned int;

  static constexpr size_t position{0};

  static constexpr char const * const name{"valueUL"};

  static constexpr char const * const typestr{"unsigned int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgChar32Val::p_valueUL};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgChar32Val, unsigned int SgChar32Val::*, &SgChar32Val::p_valueUL>;

};


template <> struct describe_field_t<SgChar32Val,std::string,&SgChar32Val::p_valueString> {

  using parent = SgChar32Val;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgChar32Val::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgChar32Val, std::string SgChar32Val::*, &SgChar32Val::p_valueString>;

};


template <> struct describe_node_t<SgChar32Val> {

  using node = SgChar32Val;

  using base = SgValueExp;

  static constexpr char const * const name{"Char32Val"};

  static constexpr unsigned long variant{324};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgChar32Val,unsigned int,&SgChar32Val::p_valueUL>, describe_field_t<SgChar32Val,std::string,&SgChar32Val::p_valueString>>;

};


template <> struct node_from_variant_t<324> { using type = SgChar32Val; };


// Class: ChooseExpression


template <> struct describe_field_t<SgChooseExpression,SgExpression*,&SgChooseExpression::p_value> {

  using parent = SgChooseExpression;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgChooseExpression::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgChooseExpression, SgExpression* SgChooseExpression::*, &SgChooseExpression::p_value>;

};


template <> struct describe_node_t<SgChooseExpression> {

  using node = SgChooseExpression;

  using base = SgExpression;

  static constexpr char const * const name{"ChooseExpression"};

  static constexpr unsigned long variant{325};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgChooseExpression,SgExpression*,&SgChooseExpression::p_value>>;

};


template <> struct node_from_variant_t<325> { using type = SgChooseExpression; };


// Class: ClassDecl_attr


template <> struct describe_node_t<SgClassDecl_attr> {

  using node = SgClassDecl_attr;

  using base = SgBitAttribute;

  static constexpr char const * const name{"ClassDecl_attr"};

  static constexpr unsigned long variant{326};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<326> { using type = SgClassDecl_attr; };


// Class: ClassDeclaration


template <> struct describe_field_t<SgClassDeclaration,SgName,&SgClassDeclaration::p_name> {

  using parent = SgClassDeclaration;

  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{&SgClassDeclaration::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgName SgClassDeclaration::*, &SgClassDeclaration::p_name>;

};


template <> struct describe_field_t<SgClassDeclaration,SgClassDeclaration::class_types,&SgClassDeclaration::p_class_type> {

  using parent = SgClassDeclaration;

  using field_type = SgClassDeclaration::class_types;

  static constexpr size_t position{1};

  static constexpr char const * const name{"class_type"};

  static constexpr char const * const typestr{"SgClassDeclaration::class_types"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_class_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgClassDeclaration::class_types SgClassDeclaration::*, &SgClassDeclaration::p_class_type>;

};


template <> struct describe_field_t<SgClassDeclaration,SgClassType*,&SgClassDeclaration::p_type> {

  using parent = SgClassDeclaration;

  using field_type = SgClassType*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgClassType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgClassType* SgClassDeclaration::*, &SgClassDeclaration::p_type>;

};


template <> struct describe_field_t<SgClassDeclaration,SgClassDefinition*,&SgClassDeclaration::p_definition> {

  using parent = SgClassDeclaration;

  using field_type = SgClassDefinition*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"definition"};

  static constexpr char const * const typestr{"SgClassDefinition*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_definition};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgClassDefinition* SgClassDeclaration::*, &SgClassDeclaration::p_definition>;

};


template <> struct describe_field_t<SgClassDeclaration,SgScopeStatement*,&SgClassDeclaration::p_scope> {

  using parent = SgClassDeclaration;

  using field_type = SgScopeStatement*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"scope"};

  static constexpr char const * const typestr{"SgScopeStatement*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_scope};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgScopeStatement* SgClassDeclaration::*, &SgClassDeclaration::p_scope>;

};


template <> struct describe_field_t<SgClassDeclaration,SgDeclarationStatement::template_specialization_enum,&SgClassDeclaration::p_specialization> {

  using parent = SgClassDeclaration;

  using field_type = SgDeclarationStatement::template_specialization_enum;

  static constexpr size_t position{5};

  static constexpr char const * const name{"specialization"};

  static constexpr char const * const typestr{"SgDeclarationStatement::template_specialization_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_specialization};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgDeclarationStatement::template_specialization_enum SgClassDeclaration::*, &SgClassDeclaration::p_specialization>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_from_template> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"from_template"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_from_template};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_from_template>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_fixupScope> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"fixupScope"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_fixupScope};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_fixupScope>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isUnNamed> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{8};

  static constexpr char const * const name{"isUnNamed"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_isUnNamed};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isUnNamed>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_annotation_interface> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{9};

  static constexpr char const * const name{"explicit_annotation_interface"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_annotation_interface};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_annotation_interface>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_interface> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{10};

  static constexpr char const * const name{"explicit_interface"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_interface};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_interface>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_enum> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{11};

  static constexpr char const * const name{"explicit_enum"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_enum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_enum>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_anonymous> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{12};

  static constexpr char const * const name{"explicit_anonymous"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_anonymous};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_anonymous>;

};


template <> struct describe_field_t<SgClassDeclaration,SgExprListExp*,&SgClassDeclaration::p_decoratorList> {

  using parent = SgClassDeclaration;

  using field_type = SgExprListExp*;

  static constexpr size_t position{13};

  static constexpr char const * const name{"decoratorList"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_decoratorList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgExprListExp* SgClassDeclaration::*, &SgClassDeclaration::p_decoratorList>;

};


template <> struct describe_field_t<SgClassDeclaration,int,&SgClassDeclaration::p_name_qualification_length> {

  using parent = SgClassDeclaration;

  using field_type = int;

  static constexpr size_t position{14};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, int SgClassDeclaration::*, &SgClassDeclaration::p_name_qualification_length>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_type_elaboration_required> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{15};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_global_qualification_required> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{16};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_global_qualification_required>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isAutonomousDeclaration> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{17};

  static constexpr char const * const name{"isAutonomousDeclaration"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_isAutonomousDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isAutonomousDeclaration>;

};


template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration> {

  using parent = SgClassDeclaration;

  using field_type = bool;

  static constexpr size_t position{18};

  static constexpr char const * const name{"isRepresentingTemplateParameterInTemplateDeclaration"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration>;

};


template <> struct describe_field_t<SgClassDeclaration,SgBaseClass*,&SgClassDeclaration::p_adaParentType> {

  using parent = SgClassDeclaration;

  using field_type = SgBaseClass*;

  static constexpr size_t position{19};

  static constexpr char const * const name{"adaParentType"};

  static constexpr char const * const typestr{"SgBaseClass*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDeclaration::p_adaParentType};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDeclaration, SgBaseClass* SgClassDeclaration::*, &SgClassDeclaration::p_adaParentType>;

};


template <> struct describe_node_t<SgClassDeclaration> {

  using node = SgClassDeclaration;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"ClassDeclaration"};

  static constexpr unsigned long variant{327};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgTemplateClassDeclaration, SgTemplateInstantiationDecl, SgDerivedTypeStatement, SgModuleStatement, SgJavaPackageDeclaration, SgJovialTableStatement>;

  using fields_t = mp::List<describe_field_t<SgClassDeclaration,SgName,&SgClassDeclaration::p_name>, describe_field_t<SgClassDeclaration,SgClassDeclaration::class_types,&SgClassDeclaration::p_class_type>, describe_field_t<SgClassDeclaration,SgClassType*,&SgClassDeclaration::p_type>, describe_field_t<SgClassDeclaration,SgClassDefinition*,&SgClassDeclaration::p_definition>, describe_field_t<SgClassDeclaration,SgScopeStatement*,&SgClassDeclaration::p_scope>, describe_field_t<SgClassDeclaration,SgDeclarationStatement::template_specialization_enum,&SgClassDeclaration::p_specialization>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_from_template>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_fixupScope>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isUnNamed>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_annotation_interface>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_interface>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_enum>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_anonymous>, describe_field_t<SgClassDeclaration,SgExprListExp*,&SgClassDeclaration::p_decoratorList>, describe_field_t<SgClassDeclaration,int,&SgClassDeclaration::p_name_qualification_length>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_type_elaboration_required>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_global_qualification_required>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isAutonomousDeclaration>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration>, describe_field_t<SgClassDeclaration,SgBaseClass*,&SgClassDeclaration::p_adaParentType>>;

};


template <> struct node_from_variant_t<327> { using type = SgClassDeclaration; };


// Class: ClassDefinition


template <> struct describe_field_t<SgClassDefinition,SgDeclarationStatementPtrList,&SgClassDefinition::p_members> {

  using parent = SgClassDefinition;

  using field_type = SgDeclarationStatementPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"members"};

  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_members};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, SgDeclarationStatementPtrList SgClassDefinition::*, &SgClassDefinition::p_members>;

};


template <> struct describe_field_t<SgClassDefinition,SgBaseClassPtrList,&SgClassDefinition::p_inheritances> {

  using parent = SgClassDefinition;

  using field_type = SgBaseClassPtrList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"inheritances"};

  static constexpr char const * const typestr{"SgBaseClassPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_inheritances};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, SgBaseClassPtrList SgClassDefinition::*, &SgClassDefinition::p_inheritances>;

};


template <> struct describe_field_t<SgClassDefinition,unsigned int,&SgClassDefinition::p_packingAlignment> {

  using parent = SgClassDefinition;

  using field_type = unsigned int;

  static constexpr size_t position{2};

  static constexpr char const * const name{"packingAlignment"};

  static constexpr char const * const typestr{"unsigned int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_packingAlignment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, unsigned int SgClassDefinition::*, &SgClassDefinition::p_packingAlignment>;

};


template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isSequence> {

  using parent = SgClassDefinition;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"isSequence"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_isSequence};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isSequence>;

};


template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isPrivate> {

  using parent = SgClassDefinition;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"isPrivate"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_isPrivate};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isPrivate>;

};


template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isAbstract> {

  using parent = SgClassDefinition;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"isAbstract"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassDefinition::p_isAbstract};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isAbstract>;

};


template <> struct describe_node_t<SgClassDefinition> {

  using node = SgClassDefinition;

  using base = SgScopeStatement;

  static constexpr char const * const name{"ClassDefinition"};

  static constexpr unsigned long variant{328};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgTemplateInstantiationDefn, SgTemplateClassDefinition>;

  using fields_t = mp::List<describe_field_t<SgClassDefinition,SgDeclarationStatementPtrList,&SgClassDefinition::p_members>, describe_field_t<SgClassDefinition,SgBaseClassPtrList,&SgClassDefinition::p_inheritances>, describe_field_t<SgClassDefinition,unsigned int,&SgClassDefinition::p_packingAlignment>, describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isSequence>, describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isPrivate>, describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isAbstract>>;

};


template <> struct node_from_variant_t<328> { using type = SgClassDefinition; };


// Class: ClassNameRefExp


template <> struct describe_field_t<SgClassNameRefExp,SgClassSymbol*,&SgClassNameRefExp::p_symbol> {

  using parent = SgClassNameRefExp;

  using field_type = SgClassSymbol*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"symbol"};

  static constexpr char const * const typestr{"SgClassSymbol*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassNameRefExp::p_symbol};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassNameRefExp, SgClassSymbol* SgClassNameRefExp::*, &SgClassNameRefExp::p_symbol>;

};


template <> struct describe_node_t<SgClassNameRefExp> {

  using node = SgClassNameRefExp;

  using base = SgReferenceExp;

  static constexpr char const * const name{"ClassNameRefExp"};

  static constexpr unsigned long variant{329};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgClassNameRefExp,SgClassSymbol*,&SgClassNameRefExp::p_symbol>>;

};


template <> struct node_from_variant_t<329> { using type = SgClassNameRefExp; };


// Class: ClassSymbol


template <> struct describe_field_t<SgClassSymbol,SgClassDeclaration*,&SgClassSymbol::p_declaration> {

  using parent = SgClassSymbol;

  using field_type = SgClassDeclaration*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgClassDeclaration*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgClassSymbol::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassSymbol, SgClassDeclaration* SgClassSymbol::*, &SgClassSymbol::p_declaration>;

};


template <> struct describe_node_t<SgClassSymbol> {

  using node = SgClassSymbol;

  using base = SgTypeSymbol;

  static constexpr char const * const name{"ClassSymbol"};

  static constexpr unsigned long variant{330};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgTemplateClassSymbol>;

  using fields_t = mp::List<describe_field_t<SgClassSymbol,SgClassDeclaration*,&SgClassSymbol::p_declaration>>;

};


template <> struct node_from_variant_t<330> { using type = SgClassSymbol; };


// Class: ClassType


template <> struct describe_field_t<SgClassType,bool,&SgClassType::p_packed> {

  using parent = SgClassType;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"packed"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClassType::p_packed};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClassType, bool SgClassType::*, &SgClassType::p_packed>;

};


template <> struct describe_node_t<SgClassType> {

  using node = SgClassType;

  using base = SgNamedType;

  static constexpr char const * const name{"ClassType"};

  static constexpr unsigned long variant{331};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgJavaParameterType, SgJovialTableType>;

  using fields_t = mp::List<describe_field_t<SgClassType,bool,&SgClassType::p_packed>>;

};


template <> struct node_from_variant_t<331> { using type = SgClassType; };


// Class: ClinkageDeclarationStatement


template <> struct describe_field_t<SgClinkageDeclarationStatement,std::string,&SgClinkageDeclarationStatement::p_languageSpecifier> {

  using parent = SgClinkageDeclarationStatement;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"languageSpecifier"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgClinkageDeclarationStatement::p_languageSpecifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgClinkageDeclarationStatement, std::string SgClinkageDeclarationStatement::*, &SgClinkageDeclarationStatement::p_languageSpecifier>;

};


template <> struct describe_node_t<SgClinkageDeclarationStatement> {

  using node = SgClinkageDeclarationStatement;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"ClinkageDeclarationStatement"};

  static constexpr unsigned long variant{332};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgClinkageStartStatement, SgClinkageEndStatement>;

  using fields_t = mp::List<describe_field_t<SgClinkageDeclarationStatement,std::string,&SgClinkageDeclarationStatement::p_languageSpecifier>>;

};


template <> struct node_from_variant_t<332> { using type = SgClinkageDeclarationStatement; };


// Class: ClinkageEndStatement


template <> struct describe_node_t<SgClinkageEndStatement> {

  using node = SgClinkageEndStatement;

  using base = SgClinkageDeclarationStatement;

  static constexpr char const * const name{"ClinkageEndStatement"};

  static constexpr unsigned long variant{333};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<333> { using type = SgClinkageEndStatement; };


// Class: ClinkageStartStatement


template <> struct describe_node_t<SgClinkageStartStatement> {

  using node = SgClinkageStartStatement;

  using base = SgClinkageDeclarationStatement;

  static constexpr char const * const name{"ClinkageStartStatement"};

  static constexpr unsigned long variant{334};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<334> { using type = SgClinkageStartStatement; };


// Class: CloseStatement


template <> struct describe_field_t<SgCloseStatement,SgExpression*,&SgCloseStatement::p_status> {

  using parent = SgCloseStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"status"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCloseStatement::p_status};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCloseStatement, SgExpression* SgCloseStatement::*, &SgCloseStatement::p_status>;

};


template <> struct describe_node_t<SgCloseStatement> {

  using node = SgCloseStatement;

  using base = SgIOStatement;

  static constexpr char const * const name{"CloseStatement"};

  static constexpr unsigned long variant{335};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCloseStatement,SgExpression*,&SgCloseStatement::p_status>>;

};


template <> struct node_from_variant_t<335> { using type = SgCloseStatement; };


// Class: ColonShapeExp


template <> struct describe_node_t<SgColonShapeExp> {

  using node = SgColonShapeExp;

  using base = SgExpression;

  static constexpr char const * const name{"ColonShapeExp"};

  static constexpr unsigned long variant{336};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<336> { using type = SgColonShapeExp; };


// Class: CommaOpExp


template <> struct describe_node_t<SgCommaOpExp> {

  using node = SgCommaOpExp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"CommaOpExp"};

  static constexpr unsigned long variant{337};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<337> { using type = SgCommaOpExp; };


// Class: CommonBlock


template <> struct describe_field_t<SgCommonBlock,SgCommonBlockObjectPtrList,&SgCommonBlock::p_block_list> {

  using parent = SgCommonBlock;

  using field_type = SgCommonBlockObjectPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"block_list"};

  static constexpr char const * const typestr{"SgCommonBlockObjectPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCommonBlock::p_block_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCommonBlock, SgCommonBlockObjectPtrList SgCommonBlock::*, &SgCommonBlock::p_block_list>;

};


template <> struct describe_node_t<SgCommonBlock> {

  using node = SgCommonBlock;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"CommonBlock"};

  static constexpr unsigned long variant{338};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCommonBlock,SgCommonBlockObjectPtrList,&SgCommonBlock::p_block_list>>;

};


template <> struct node_from_variant_t<338> { using type = SgCommonBlock; };


// Class: CommonBlockObject


template <> struct describe_field_t<SgCommonBlockObject,std::string,&SgCommonBlockObject::p_block_name> {

  using parent = SgCommonBlockObject;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"block_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCommonBlockObject::p_block_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCommonBlockObject, std::string SgCommonBlockObject::*, &SgCommonBlockObject::p_block_name>;

};


template <> struct describe_field_t<SgCommonBlockObject,SgExprListExp*,&SgCommonBlockObject::p_variable_reference_list> {

  using parent = SgCommonBlockObject;

  using field_type = SgExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"variable_reference_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCommonBlockObject::p_variable_reference_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCommonBlockObject, SgExprListExp* SgCommonBlockObject::*, &SgCommonBlockObject::p_variable_reference_list>;

};


template <> struct describe_node_t<SgCommonBlockObject> {

  using node = SgCommonBlockObject;

  using base = SgLocatedNodeSupport;

  static constexpr char const * const name{"CommonBlockObject"};

  static constexpr unsigned long variant{339};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCommonBlockObject,std::string,&SgCommonBlockObject::p_block_name>, describe_field_t<SgCommonBlockObject,SgExprListExp*,&SgCommonBlockObject::p_variable_reference_list>>;

};


template <> struct node_from_variant_t<339> { using type = SgCommonBlockObject; };


// Class: CommonSymbol


template <> struct describe_field_t<SgCommonSymbol,SgInitializedName*,&SgCommonSymbol::p_declaration> {

  using parent = SgCommonSymbol;

  using field_type = SgInitializedName*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgInitializedName*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCommonSymbol::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCommonSymbol, SgInitializedName* SgCommonSymbol::*, &SgCommonSymbol::p_declaration>;

};


template <> struct describe_node_t<SgCommonSymbol> {

  using node = SgCommonSymbol;

  using base = SgSymbol;

  static constexpr char const * const name{"CommonSymbol"};

  static constexpr unsigned long variant{340};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCommonSymbol,SgInitializedName*,&SgCommonSymbol::p_declaration>>;

};


template <> struct node_from_variant_t<340> { using type = SgCommonSymbol; };


// Class: ComplexVal


template <> struct describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_real_value> {

  using parent = SgComplexVal;

  using field_type = SgValueExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"real_value"};

  static constexpr char const * const typestr{"SgValueExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComplexVal::p_real_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComplexVal, SgValueExp* SgComplexVal::*, &SgComplexVal::p_real_value>;

};


template <> struct describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_imaginary_value> {

  using parent = SgComplexVal;

  using field_type = SgValueExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"imaginary_value"};

  static constexpr char const * const typestr{"SgValueExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComplexVal::p_imaginary_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComplexVal, SgValueExp* SgComplexVal::*, &SgComplexVal::p_imaginary_value>;

};


template <> struct describe_field_t<SgComplexVal,SgType*,&SgComplexVal::p_precisionType> {

  using parent = SgComplexVal;

  using field_type = SgType*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"precisionType"};

  static constexpr char const * const typestr{"SgType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgComplexVal::p_precisionType};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComplexVal, SgType* SgComplexVal::*, &SgComplexVal::p_precisionType>;

};


template <> struct describe_field_t<SgComplexVal,std::string,&SgComplexVal::p_valueString> {

  using parent = SgComplexVal;

  using field_type = std::string;

  static constexpr size_t position{3};

  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{&SgComplexVal::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComplexVal, std::string SgComplexVal::*, &SgComplexVal::p_valueString>;

};


template <> struct describe_node_t<SgComplexVal> {

  using node = SgComplexVal;

  using base = SgValueExp;

  static constexpr char const * const name{"ComplexVal"};

  static constexpr unsigned long variant{341};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_real_value>, describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_imaginary_value>, describe_field_t<SgComplexVal,SgType*,&SgComplexVal::p_precisionType>, describe_field_t<SgComplexVal,std::string,&SgComplexVal::p_valueString>>;

};


template <> struct node_from_variant_t<341> { using type = SgComplexVal; };


// Class: Comprehension


template <> struct describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_target> {

  using parent = SgComprehension;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"target"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComprehension::p_target};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComprehension, SgExpression* SgComprehension::*, &SgComprehension::p_target>;

};


template <> struct describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_iter> {

  using parent = SgComprehension;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"iter"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComprehension::p_iter};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComprehension, SgExpression* SgComprehension::*, &SgComprehension::p_iter>;

};


template <> struct describe_field_t<SgComprehension,SgExprListExp*,&SgComprehension::p_filters> {

  using parent = SgComprehension;

  using field_type = SgExprListExp*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"filters"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComprehension::p_filters};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComprehension, SgExprListExp* SgComprehension::*, &SgComprehension::p_filters>;

};


template <> struct describe_node_t<SgComprehension> {

  using node = SgComprehension;

  using base = SgExpression;

  static constexpr char const * const name{"Comprehension"};

  static constexpr unsigned long variant{342};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_target>, describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_iter>, describe_field_t<SgComprehension,SgExprListExp*,&SgComprehension::p_filters>>;

};


template <> struct node_from_variant_t<342> { using type = SgComprehension; };


// Class: CompoundAssignOp


template <> struct describe_node_t<SgCompoundAssignOp> {

  using node = SgCompoundAssignOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"CompoundAssignOp"};

  static constexpr unsigned long variant{344};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgPlusAssignOp, SgMinusAssignOp, SgAndAssignOp, SgIorAssignOp, SgMultAssignOp, SgDivAssignOp, SgModAssignOp, SgXorAssignOp, SgLshiftAssignOp, SgRshiftAssignOp, SgJavaUnsignedRshiftAssignOp, SgIntegerDivideAssignOp, SgExponentiationAssignOp>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<344> { using type = SgCompoundAssignOp; };


// Class: CompoundInitializer


template <> struct describe_field_t<SgCompoundInitializer,SgExprListExp*,&SgCompoundInitializer::p_initializers> {

  using parent = SgCompoundInitializer;

  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{&SgCompoundInitializer::p_initializers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCompoundInitializer, SgExprListExp* SgCompoundInitializer::*, &SgCompoundInitializer::p_initializers>;

};


template <> struct describe_field_t<SgCompoundInitializer,SgType*,&SgCompoundInitializer::p_expression_type> {

  using parent = SgCompoundInitializer;

  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{&SgCompoundInitializer::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCompoundInitializer, SgType* SgCompoundInitializer::*, &SgCompoundInitializer::p_expression_type>;

};


template <> struct describe_node_t<SgCompoundInitializer> {

  using node = SgCompoundInitializer;

  using base = SgInitializer;

  static constexpr char const * const name{"CompoundInitializer"};

  static constexpr unsigned long variant{345};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCompoundInitializer,SgExprListExp*,&SgCompoundInitializer::p_initializers>, describe_field_t<SgCompoundInitializer,SgType*,&SgCompoundInitializer::p_expression_type>>;

};


template <> struct node_from_variant_t<345> { using type = SgCompoundInitializer; };


// Class: CompoundLiteralExp


template <> struct describe_field_t<SgCompoundLiteralExp,SgVariableSymbol*,&SgCompoundLiteralExp::p_symbol> {

  using parent = SgCompoundLiteralExp;

  using field_type = SgVariableSymbol*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"symbol"};

  static constexpr char const * const typestr{"SgVariableSymbol*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgCompoundLiteralExp::p_symbol};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCompoundLiteralExp, SgVariableSymbol* SgCompoundLiteralExp::*, &SgCompoundLiteralExp::p_symbol>;

};


template <> struct describe_node_t<SgCompoundLiteralExp> {

  using node = SgCompoundLiteralExp;

  using base = SgExpression;

  static constexpr char const * const name{"CompoundLiteralExp"};

  static constexpr unsigned long variant{346};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCompoundLiteralExp,SgVariableSymbol*,&SgCompoundLiteralExp::p_symbol>>;

};


template <> struct node_from_variant_t<346> { using type = SgCompoundLiteralExp; };


// Class: ComputedGotoStatement


template <> struct describe_field_t<SgComputedGotoStatement,SgExprListExp*,&SgComputedGotoStatement::p_labelList> {

  using parent = SgComputedGotoStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"labelList"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComputedGotoStatement::p_labelList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComputedGotoStatement, SgExprListExp* SgComputedGotoStatement::*, &SgComputedGotoStatement::p_labelList>;

};


template <> struct describe_field_t<SgComputedGotoStatement,SgExpression*,&SgComputedGotoStatement::p_label_index> {

  using parent = SgComputedGotoStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"label_index"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgComputedGotoStatement::p_label_index};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgComputedGotoStatement, SgExpression* SgComputedGotoStatement::*, &SgComputedGotoStatement::p_label_index>;

};


template <> struct describe_node_t<SgComputedGotoStatement> {

  using node = SgComputedGotoStatement;

  using base = SgStatement;

  static constexpr char const * const name{"ComputedGotoStatement"};

  static constexpr unsigned long variant{347};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgComputedGotoStatement,SgExprListExp*,&SgComputedGotoStatement::p_labelList>, describe_field_t<SgComputedGotoStatement,SgExpression*,&SgComputedGotoStatement::p_label_index>>;

};


template <> struct node_from_variant_t<347> { using type = SgComputedGotoStatement; };


// Class: ConcatenationOp


template <> struct describe_node_t<SgConcatenationOp> {

  using node = SgConcatenationOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"ConcatenationOp"};

  static constexpr unsigned long variant{348};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<348> { using type = SgConcatenationOp; };


// Class: ConditionalExp


template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_conditional_exp> {

  using parent = SgConditionalExp;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"conditional_exp"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgConditionalExp::p_conditional_exp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_conditional_exp>;

};


template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_true_exp> {

  using parent = SgConditionalExp;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"true_exp"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgConditionalExp::p_true_exp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_true_exp>;

};


template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_false_exp> {

  using parent = SgConditionalExp;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"false_exp"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgConditionalExp::p_false_exp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_false_exp>;

};


template <> struct describe_field_t<SgConditionalExp,SgType*,&SgConditionalExp::p_expression_type> {

  using parent = SgConditionalExp;

  using field_type = SgType*;

  static constexpr size_t position{3};

  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{&SgConditionalExp::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConditionalExp, SgType* SgConditionalExp::*, &SgConditionalExp::p_expression_type>;

};


template <> struct describe_node_t<SgConditionalExp> {

  using node = SgConditionalExp;

  using base = SgExpression;

  static constexpr char const * const name{"ConditionalExp"};

  static constexpr unsigned long variant{349};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_conditional_exp>, describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_true_exp>, describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_false_exp>, describe_field_t<SgConditionalExp,SgType*,&SgConditionalExp::p_expression_type>>;

};


template <> struct node_from_variant_t<349> { using type = SgConditionalExp; };


// Class: ConjugateOp


template <> struct describe_node_t<SgConjugateOp> {

  using node = SgConjugateOp;

  using base = SgUnaryOp;

  static constexpr char const * const name{"ConjugateOp"};

  static constexpr unsigned long variant{350};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<350> { using type = SgConjugateOp; };


// Class: ConstVolatileModifier


template <> struct describe_field_t<SgConstVolatileModifier,SgConstVolatileModifier::cv_modifier_enum,&SgConstVolatileModifier::p_modifier> {

  using parent = SgConstVolatileModifier;

  using field_type = SgConstVolatileModifier::cv_modifier_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"modifier"};

  static constexpr char const * const typestr{"SgConstVolatileModifier::cv_modifier_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstVolatileModifier::p_modifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstVolatileModifier, SgConstVolatileModifier::cv_modifier_enum SgConstVolatileModifier::*, &SgConstVolatileModifier::p_modifier>;

};


template <> struct describe_node_t<SgConstVolatileModifier> {

  using node = SgConstVolatileModifier;

  using base = SgModifier;

  static constexpr char const * const name{"ConstVolatileModifier"};

  static constexpr unsigned long variant{351};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgConstVolatileModifier,SgConstVolatileModifier::cv_modifier_enum,&SgConstVolatileModifier::p_modifier>>;

};


template <> struct node_from_variant_t<351> { using type = SgConstVolatileModifier; };


// Class: ConstructorInitializer


template <> struct describe_field_t<SgConstructorInitializer,SgMemberFunctionDeclaration*,&SgConstructorInitializer::p_declaration> {

  using parent = SgConstructorInitializer;

  using field_type = SgMemberFunctionDeclaration*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgMemberFunctionDeclaration*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, SgMemberFunctionDeclaration* SgConstructorInitializer::*, &SgConstructorInitializer::p_declaration>;

};


template <> struct describe_field_t<SgConstructorInitializer,SgExprListExp*,&SgConstructorInitializer::p_args> {

  using parent = SgConstructorInitializer;

  using field_type = SgExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"args"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_args};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, SgExprListExp* SgConstructorInitializer::*, &SgConstructorInitializer::p_args>;

};


template <> struct describe_field_t<SgConstructorInitializer,SgType*,&SgConstructorInitializer::p_expression_type> {

  using parent = SgConstructorInitializer;

  using field_type = SgType*;

  static constexpr size_t position{2};

  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{&SgConstructorInitializer::p_expression_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, SgType* SgConstructorInitializer::*, &SgConstructorInitializer::p_expression_type>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_name> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"need_name"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_name>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_qualifier> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"need_qualifier"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_qualifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_qualifier>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_parenthesis_after_name> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"need_parenthesis_after_name"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_parenthesis_after_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_parenthesis_after_name>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_associated_class_unknown> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"associated_class_unknown"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_associated_class_unknown};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_associated_class_unknown>;

};


template <> struct describe_field_t<SgConstructorInitializer,int,&SgConstructorInitializer::p_name_qualification_length> {

  using parent = SgConstructorInitializer;

  using field_type = int;

  static constexpr size_t position{7};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, int SgConstructorInitializer::*, &SgConstructorInitializer::p_name_qualification_length>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_type_elaboration_required> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{8};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_global_qualification_required> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{9};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_global_qualification_required>;

};


template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_is_used_in_conditional> {

  using parent = SgConstructorInitializer;

  using field_type = bool;

  static constexpr size_t position{10};

  static constexpr char const * const name{"is_used_in_conditional"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgConstructorInitializer::p_is_used_in_conditional};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_is_used_in_conditional>;

};


template <> struct describe_node_t<SgConstructorInitializer> {

  using node = SgConstructorInitializer;

  using base = SgInitializer;

  static constexpr char const * const name{"ConstructorInitializer"};

  static constexpr unsigned long variant{352};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgConstructorInitializer,SgMemberFunctionDeclaration*,&SgConstructorInitializer::p_declaration>, describe_field_t<SgConstructorInitializer,SgExprListExp*,&SgConstructorInitializer::p_args>, describe_field_t<SgConstructorInitializer,SgType*,&SgConstructorInitializer::p_expression_type>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_name>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_qualifier>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_parenthesis_after_name>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_associated_class_unknown>, describe_field_t<SgConstructorInitializer,int,&SgConstructorInitializer::p_name_qualification_length>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_type_elaboration_required>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_global_qualification_required>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_is_used_in_conditional>>;

};


template <> struct node_from_variant_t<352> { using type = SgConstructorInitializer; };


// Class: ContainsStatement


template <> struct describe_node_t<SgContainsStatement> {

  using node = SgContainsStatement;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"ContainsStatement"};

  static constexpr unsigned long variant{353};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<353> { using type = SgContainsStatement; };


// Class: ContinueStmt


template <> struct describe_field_t<SgContinueStmt,std::string,&SgContinueStmt::p_do_string_label> {

  using parent = SgContinueStmt;

  using field_type = std::string;

  static constexpr size_t position{0};

  static constexpr char const * const name{"do_string_label"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgContinueStmt::p_do_string_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgContinueStmt, std::string SgContinueStmt::*, &SgContinueStmt::p_do_string_label>;

};


template <> struct describe_node_t<SgContinueStmt> {

  using node = SgContinueStmt;

  using base = SgStatement;

  static constexpr char const * const name{"ContinueStmt"};

  static constexpr unsigned long variant{354};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgContinueStmt,std::string,&SgContinueStmt::p_do_string_label>>;

};


template <> struct node_from_variant_t<354> { using type = SgContinueStmt; };


// Class: CtorInitializerList


template <> struct describe_field_t<SgCtorInitializerList,SgInitializedNamePtrList,&SgCtorInitializerList::p_ctors> {

  using parent = SgCtorInitializerList;

  using field_type = SgInitializedNamePtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"ctors"};

  static constexpr char const * const typestr{"SgInitializedNamePtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgCtorInitializerList::p_ctors};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgCtorInitializerList, SgInitializedNamePtrList SgCtorInitializerList::*, &SgCtorInitializerList::p_ctors>;

};


template <> struct describe_node_t<SgCtorInitializerList> {

  using node = SgCtorInitializerList;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"CtorInitializerList"};

  static constexpr unsigned long variant{355};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgCtorInitializerList,SgInitializedNamePtrList,&SgCtorInitializerList::p_ctors>>;

};


template <> struct node_from_variant_t<355> { using type = SgCtorInitializerList; };


// Class: DataStatementGroup


template <> struct describe_field_t<SgDataStatementGroup,SgDataStatementObjectPtrList,&SgDataStatementGroup::p_object_list> {

  using parent = SgDataStatementGroup;

  using field_type = SgDataStatementObjectPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"object_list"};

  static constexpr char const * const typestr{"SgDataStatementObjectPtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementGroup::p_object_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementGroup, SgDataStatementObjectPtrList SgDataStatementGroup::*, &SgDataStatementGroup::p_object_list>;

};


template <> struct describe_field_t<SgDataStatementGroup,SgDataStatementValuePtrList,&SgDataStatementGroup::p_value_list> {

  using parent = SgDataStatementGroup;

  using field_type = SgDataStatementValuePtrList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"value_list"};

  static constexpr char const * const typestr{"SgDataStatementValuePtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementGroup::p_value_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementGroup, SgDataStatementValuePtrList SgDataStatementGroup::*, &SgDataStatementGroup::p_value_list>;

};


template <> struct describe_node_t<SgDataStatementGroup> {

  using node = SgDataStatementGroup;

  using base = SgSupport;

  static constexpr char const * const name{"DataStatementGroup"};

  static constexpr unsigned long variant{356};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDataStatementGroup,SgDataStatementObjectPtrList,&SgDataStatementGroup::p_object_list>, describe_field_t<SgDataStatementGroup,SgDataStatementValuePtrList,&SgDataStatementGroup::p_value_list>>;

};


template <> struct node_from_variant_t<356> { using type = SgDataStatementGroup; };


// Class: DataStatementObject


template <> struct describe_field_t<SgDataStatementObject,SgExprListExp*,&SgDataStatementObject::p_variableReference_list> {

  using parent = SgDataStatementObject;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"variableReference_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementObject::p_variableReference_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementObject, SgExprListExp* SgDataStatementObject::*, &SgDataStatementObject::p_variableReference_list>;

};


template <> struct describe_node_t<SgDataStatementObject> {

  using node = SgDataStatementObject;

  using base = SgSupport;

  static constexpr char const * const name{"DataStatementObject"};

  static constexpr unsigned long variant{357};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDataStatementObject,SgExprListExp*,&SgDataStatementObject::p_variableReference_list>>;

};


template <> struct node_from_variant_t<357> { using type = SgDataStatementObject; };


// Class: DataStatementValue


template <> struct describe_field_t<SgDataStatementValue,SgDataStatementValue::data_statement_value_enum,&SgDataStatementValue::p_data_initialization_format> {

  using parent = SgDataStatementValue;

  using field_type = SgDataStatementValue::data_statement_value_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"data_initialization_format"};

  static constexpr char const * const typestr{"SgDataStatementValue::data_statement_value_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementValue::p_data_initialization_format};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementValue, SgDataStatementValue::data_statement_value_enum SgDataStatementValue::*, &SgDataStatementValue::p_data_initialization_format>;

};


template <> struct describe_field_t<SgDataStatementValue,SgExprListExp*,&SgDataStatementValue::p_initializer_list> {

  using parent = SgDataStatementValue;

  using field_type = SgExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"initializer_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementValue::p_initializer_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementValue, SgExprListExp* SgDataStatementValue::*, &SgDataStatementValue::p_initializer_list>;

};


template <> struct describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_repeat_expression> {

  using parent = SgDataStatementValue;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"repeat_expression"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementValue::p_repeat_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementValue, SgExpression* SgDataStatementValue::*, &SgDataStatementValue::p_repeat_expression>;

};


template <> struct describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_constant_expression> {

  using parent = SgDataStatementValue;

  using field_type = SgExpression*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"constant_expression"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDataStatementValue::p_constant_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDataStatementValue, SgExpression* SgDataStatementValue::*, &SgDataStatementValue::p_constant_expression>;

};


template <> struct describe_node_t<SgDataStatementValue> {

  using node = SgDataStatementValue;

  using base = SgSupport;

  static constexpr char const * const name{"DataStatementValue"};

  static constexpr unsigned long variant{358};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDataStatementValue,SgDataStatementValue::data_statement_value_enum,&SgDataStatementValue::p_data_initialization_format>, describe_field_t<SgDataStatementValue,SgExprListExp*,&SgDataStatementValue::p_initializer_list>, describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_repeat_expression>, describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_constant_expression>>;

};


template <> struct node_from_variant_t<358> { using type = SgDataStatementValue; };


// Class: DeadIfDirectiveStatement


template <> struct describe_node_t<SgDeadIfDirectiveStatement> {

  using node = SgDeadIfDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"DeadIfDirectiveStatement"};

  static constexpr unsigned long variant{359};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<359> { using type = SgDeadIfDirectiveStatement; };


// Class: DeallocateStatement


template <> struct describe_field_t<SgDeallocateStatement,SgExprListExp*,&SgDeallocateStatement::p_expr_list> {

  using parent = SgDeallocateStatement;

  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{&SgDeallocateStatement::p_expr_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeallocateStatement, SgExprListExp* SgDeallocateStatement::*, &SgDeallocateStatement::p_expr_list>;

};


template <> struct describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_stat_expression> {

  using parent = SgDeallocateStatement;

  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{&SgDeallocateStatement::p_stat_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeallocateStatement, SgExpression* SgDeallocateStatement::*, &SgDeallocateStatement::p_stat_expression>;

};


template <> struct describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_errmsg_expression> {

  using parent = SgDeallocateStatement;

  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{&SgDeallocateStatement::p_errmsg_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeallocateStatement, SgExpression* SgDeallocateStatement::*, &SgDeallocateStatement::p_errmsg_expression>;

};


template <> struct describe_node_t<SgDeallocateStatement> {

  using node = SgDeallocateStatement;

  using base = SgStatement;

  static constexpr char const * const name{"DeallocateStatement"};

  static constexpr unsigned long variant{360};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDeallocateStatement,SgExprListExp*,&SgDeallocateStatement::p_expr_list>, describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_stat_expression>, describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_errmsg_expression>>;

};


template <> struct node_from_variant_t<360> { using type = SgDeallocateStatement; };


// Class: DeclarationModifier


template <> struct describe_field_t<SgDeclarationModifier,SgBitVector,&SgDeclarationModifier::p_modifierVector> {

  using parent = SgDeclarationModifier;

  using field_type = SgBitVector;

  static constexpr size_t position{0};

  static constexpr char const * const name{"modifierVector"};

  static constexpr char const * const typestr{"SgBitVector"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_modifierVector};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, SgBitVector SgDeclarationModifier::*, &SgDeclarationModifier::p_modifierVector>;

};


template <> struct describe_field_t<SgDeclarationModifier,SgTypeModifier,&SgDeclarationModifier::p_typeModifier> {

  using parent = SgDeclarationModifier;

  using field_type = SgTypeModifier;

  static constexpr size_t position{1};

  static constexpr char const * const name{"typeModifier"};

  static constexpr char const * const typestr{"SgTypeModifier"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_typeModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, SgTypeModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_typeModifier>;

};


template <> struct describe_field_t<SgDeclarationModifier,SgAccessModifier,&SgDeclarationModifier::p_accessModifier> {

  using parent = SgDeclarationModifier;

  using field_type = SgAccessModifier;

  static constexpr size_t position{2};

  static constexpr char const * const name{"accessModifier"};

  static constexpr char const * const typestr{"SgAccessModifier"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_accessModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, SgAccessModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_accessModifier>;

};


template <> struct describe_field_t<SgDeclarationModifier,SgStorageModifier,&SgDeclarationModifier::p_storageModifier> {

  using parent = SgDeclarationModifier;

  using field_type = SgStorageModifier;

  static constexpr size_t position{3};

  static constexpr char const * const name{"storageModifier"};

  static constexpr char const * const typestr{"SgStorageModifier"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_storageModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, SgStorageModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_storageModifier>;

};


template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_gnu_attribute_section_name> {

  using parent = SgDeclarationModifier;

  using field_type = std::string;

  static constexpr size_t position{4};

  static constexpr char const * const name{"gnu_attribute_section_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_gnu_attribute_section_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_gnu_attribute_section_name>;

};


template <> struct describe_field_t<SgDeclarationModifier,SgDeclarationModifier::gnu_declaration_visability_enum,&SgDeclarationModifier::p_gnu_attribute_visability> {

  using parent = SgDeclarationModifier;

  using field_type = SgDeclarationModifier::gnu_declaration_visability_enum;

  static constexpr size_t position{5};

  static constexpr char const * const name{"gnu_attribute_visability"};

  static constexpr char const * const typestr{"SgDeclarationModifier::gnu_declaration_visability_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_gnu_attribute_visability};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, SgDeclarationModifier::gnu_declaration_visability_enum SgDeclarationModifier::*, &SgDeclarationModifier::p_gnu_attribute_visability>;

};


template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_uuid_string> {

  using parent = SgDeclarationModifier;

  using field_type = std::string;

  static constexpr size_t position{6};

  static constexpr char const * const name{"microsoft_uuid_string"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_uuid_string};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_uuid_string>;

};


template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_get_function_name> {

  using parent = SgDeclarationModifier;

  using field_type = std::string;

  static constexpr size_t position{7};

  static constexpr char const * const name{"microsoft_property_get_function_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_property_get_function_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_property_get_function_name>;

};


template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_put_function_name> {

  using parent = SgDeclarationModifier;

  using field_type = std::string;

  static constexpr size_t position{8};

  static constexpr char const * const name{"microsoft_property_put_function_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_property_put_function_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_property_put_function_name>;

};


template <> struct describe_node_t<SgDeclarationModifier> {

  using node = SgDeclarationModifier;

  using base = SgModifier;

  static constexpr char const * const name{"DeclarationModifier"};

  static constexpr unsigned long variant{361};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDeclarationModifier,SgBitVector,&SgDeclarationModifier::p_modifierVector>, describe_field_t<SgDeclarationModifier,SgTypeModifier,&SgDeclarationModifier::p_typeModifier>, describe_field_t<SgDeclarationModifier,SgAccessModifier,&SgDeclarationModifier::p_accessModifier>, describe_field_t<SgDeclarationModifier,SgStorageModifier,&SgDeclarationModifier::p_storageModifier>, describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_gnu_attribute_section_name>, describe_field_t<SgDeclarationModifier,SgDeclarationModifier::gnu_declaration_visability_enum,&SgDeclarationModifier::p_gnu_attribute_visability>, describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_uuid_string>, describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_get_function_name>, describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_put_function_name>>;

};


template <> struct node_from_variant_t<361> { using type = SgDeclarationModifier; };


// Class: DeclarationScope


template <> struct describe_node_t<SgDeclarationScope> {

  using node = SgDeclarationScope;

  using base = SgScopeStatement;

  static constexpr char const * const name{"DeclarationScope"};

  static constexpr unsigned long variant{362};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<362> { using type = SgDeclarationScope; };


// Class: DeclarationStatement


template <> struct describe_field_t<SgDeclarationStatement,unsigned int,&SgDeclarationStatement::p_decl_attributes> {

  using parent = SgDeclarationStatement;

  using field_type = unsigned int;

  static constexpr size_t position{0};

  static constexpr char const * const name{"decl_attributes"};

  static constexpr char const * const typestr{"unsigned int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_decl_attributes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, unsigned int SgDeclarationStatement::*, &SgDeclarationStatement::p_decl_attributes>;

};


template <> struct describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_linkage> {

  using parent = SgDeclarationStatement;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"linkage"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_linkage};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, std::string SgDeclarationStatement::*, &SgDeclarationStatement::p_linkage>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationModifier,&SgDeclarationStatement::p_declarationModifier> {

  using parent = SgDeclarationStatement;

  using field_type = SgDeclarationModifier;

  static constexpr size_t position{2};

  static constexpr char const * const name{"declarationModifier"};

  static constexpr char const * const typestr{"SgDeclarationModifier"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_declarationModifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgDeclarationModifier SgDeclarationStatement::*, &SgDeclarationStatement::p_declarationModifier>;

};


template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_nameOnly> {

  using parent = SgDeclarationStatement;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"nameOnly"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_nameOnly};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_nameOnly>;

};


template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_forward> {

  using parent = SgDeclarationStatement;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"forward"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_forward};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_forward>;

};


template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_externBrace> {

  using parent = SgDeclarationStatement;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"externBrace"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_externBrace};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_externBrace>;

};


template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_skipElaborateType> {

  using parent = SgDeclarationStatement;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"skipElaborateType"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_skipElaborateType};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_skipElaborateType>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_definingDeclaration> {

  using parent = SgDeclarationStatement;

  using field_type = SgDeclarationStatement*;

  static constexpr size_t position{7};

  static constexpr char const * const name{"definingDeclaration"};

  static constexpr char const * const typestr{"SgDeclarationStatement*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_definingDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgDeclarationStatement* SgDeclarationStatement::*, &SgDeclarationStatement::p_definingDeclaration>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_firstNondefiningDeclaration> {

  using parent = SgDeclarationStatement;

  using field_type = SgDeclarationStatement*;

  static constexpr size_t position{8};

  static constexpr char const * const name{"firstNondefiningDeclaration"};

  static constexpr char const * const typestr{"SgDeclarationStatement*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_firstNondefiningDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgDeclarationStatement* SgDeclarationStatement::*, &SgDeclarationStatement::p_firstNondefiningDeclaration>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgQualifiedNamePtrList,&SgDeclarationStatement::p_qualifiedNameList> {

  using parent = SgDeclarationStatement;

  using field_type = SgQualifiedNamePtrList;

  static constexpr size_t position{9};

  static constexpr char const * const name{"qualifiedNameList"};

  static constexpr char const * const typestr{"SgQualifiedNamePtrList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_qualifiedNameList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgQualifiedNamePtrList SgDeclarationStatement::*, &SgDeclarationStatement::p_qualifiedNameList>;

};


template <> struct describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_binding_label> {

  using parent = SgDeclarationStatement;

  using field_type = std::string;

  static constexpr size_t position{10};

  static constexpr char const * const name{"binding_label"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_binding_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, std::string SgDeclarationStatement::*, &SgDeclarationStatement::p_binding_label>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationScope*,&SgDeclarationStatement::p_declarationScope> {

  using parent = SgDeclarationStatement;

  using field_type = SgDeclarationScope*;

  static constexpr size_t position{11};

  static constexpr char const * const name{"declarationScope"};

  static constexpr char const * const typestr{"SgDeclarationScope*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_declarationScope};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgDeclarationScope* SgDeclarationStatement::*, &SgDeclarationStatement::p_declarationScope>;

};


template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_unparse_template_ast> {

  using parent = SgDeclarationStatement;

  using field_type = bool;

  static constexpr size_t position{12};

  static constexpr char const * const name{"unparse_template_ast"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_unparse_template_ast};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_unparse_template_ast>;

};


template <> struct describe_field_t<SgDeclarationStatement,SgExprListExp*,&SgDeclarationStatement::p_adaAspects> {

  using parent = SgDeclarationStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{13};

  static constexpr char const * const name{"adaAspects"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclarationStatement::p_adaAspects};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclarationStatement, SgExprListExp* SgDeclarationStatement::*, &SgDeclarationStatement::p_adaAspects>;

};


template <> struct describe_node_t<SgDeclarationStatement> {

  using node = SgDeclarationStatement;

  using base = SgStatement;

  static constexpr char const * const name{"DeclarationStatement"};

  static constexpr unsigned long variant{363};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgFunctionParameterList, SgVariableDeclaration, SgVariableDefinition, SgClinkageDeclarationStatement, SgEnumDeclaration, SgAsmStmt, SgAttributeSpecificationStatement, SgFormatStatement, SgTemplateDeclaration, SgTemplateInstantiationDirectiveStatement, SgUseStatement, SgParameterStatement, SgNamespaceDeclarationStatement, SgEquivalenceStatement, SgInterfaceStatement, SgNamespaceAliasDeclarationStatement, SgCommonBlock, SgTypedefDeclaration, SgStatementFunctionStatement, SgCtorInitializerList, SgPragmaDeclaration, SgUsingDirectiveStatement, SgClassDeclaration, SgImplicitStatement, SgUsingDeclarationStatement, SgNamelistStatement, SgImportStatement, SgFunctionDeclaration, SgContainsStatement, SgC_PreprocessorDirectiveStatement, SgOmpThreadprivateStatement, SgFortranIncludeLine, SgJavaImportStatement, SgJavaPackageStatement, SgStmtDeclarationStatement, SgStaticAssertionDeclaration, SgOmpDeclareSimdStatement, SgMicrosoftAttributeDeclaration, SgJovialCompoolStatement, SgJovialDirectiveStatement, SgJovialDefineDeclaration, SgJovialLabelDeclaration, SgJovialOverlayDeclaration, SgNonrealDecl, SgEmptyDeclaration, SgAdaPackageBodyDecl, SgAdaPackageSpecDecl, SgAdaRenamingDecl, SgAdaTaskSpecDecl, SgAdaTaskBodyDecl, SgAdaTaskTypeDecl, SgAdaProtectedSpecDecl, SgAdaProtectedBodyDecl, SgAdaProtectedTypeDecl, SgAdaRepresentationClause, SgAdaComponentClause, SgAdaAttributeClause, SgAdaEnumRepresentationClause, SgAdaGenericDecl, SgAdaFormalTypeDecl, SgAdaDiscriminatedTypeDecl, SgAdaGenericInstanceDecl, SgAdaFormalPackageDecl, SgAdaParameterList, SgAdaVariantDecl>;

  using fields_t = mp::List<describe_field_t<SgDeclarationStatement,unsigned int,&SgDeclarationStatement::p_decl_attributes>, describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_linkage>, describe_field_t<SgDeclarationStatement,SgDeclarationModifier,&SgDeclarationStatement::p_declarationModifier>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_nameOnly>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_forward>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_externBrace>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_skipElaborateType>, describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_definingDeclaration>, describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_firstNondefiningDeclaration>, describe_field_t<SgDeclarationStatement,SgQualifiedNamePtrList,&SgDeclarationStatement::p_qualifiedNameList>, describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_binding_label>, describe_field_t<SgDeclarationStatement,SgDeclarationScope*,&SgDeclarationStatement::p_declarationScope>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_unparse_template_ast>, describe_field_t<SgDeclarationStatement,SgExprListExp*,&SgDeclarationStatement::p_adaAspects>>;

};


template <> struct node_from_variant_t<363> { using type = SgDeclarationStatement; };


// Class: DeclType


template <> struct describe_field_t<SgDeclType,SgExpression*,&SgDeclType::p_base_expression> {

  using parent = SgDeclType;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"base_expression"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeclType::p_base_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclType, SgExpression* SgDeclType::*, &SgDeclType::p_base_expression>;

};


template <> struct describe_field_t<SgDeclType,SgType*,&SgDeclType::p_base_type> {

  using parent = SgDeclType;

  using field_type = SgType*;

  static constexpr size_t position{1};

  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{&SgDeclType::p_base_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeclType, SgType* SgDeclType::*, &SgDeclType::p_base_type>;

};


template <> struct describe_node_t<SgDeclType> {

  using node = SgDeclType;

  using base = SgType;

  static constexpr char const * const name{"DeclType"};

  static constexpr unsigned long variant{364};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDeclType,SgExpression*,&SgDeclType::p_base_expression>, describe_field_t<SgDeclType,SgType*,&SgDeclType::p_base_type>>;

};


template <> struct node_from_variant_t<364> { using type = SgDeclType; };


// Class: DefaultOptionStmt


template <> struct describe_field_t<SgDefaultOptionStmt,SgStatement*,&SgDefaultOptionStmt::p_body> {

  using parent = SgDefaultOptionStmt;

  using field_type = SgStatement*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDefaultOptionStmt, SgStatement* SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_body>;

};


template <> struct describe_field_t<SgDefaultOptionStmt,std::string,&SgDefaultOptionStmt::p_default_construct_name> {

  using parent = SgDefaultOptionStmt;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"default_construct_name"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_default_construct_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDefaultOptionStmt, std::string SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_default_construct_name>;

};


template <> struct describe_field_t<SgDefaultOptionStmt,bool,&SgDefaultOptionStmt::p_has_fall_through> {

  using parent = SgDefaultOptionStmt;

  using field_type = bool;

  static constexpr size_t position{2};

  static constexpr char const * const name{"has_fall_through"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_has_fall_through};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDefaultOptionStmt, bool SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_has_fall_through>;

};


template <> struct describe_node_t<SgDefaultOptionStmt> {

  using node = SgDefaultOptionStmt;

  using base = SgStatement;

  static constexpr char const * const name{"DefaultOptionStmt"};

  static constexpr unsigned long variant{365};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDefaultOptionStmt,SgStatement*,&SgDefaultOptionStmt::p_body>, describe_field_t<SgDefaultOptionStmt,std::string,&SgDefaultOptionStmt::p_default_construct_name>, describe_field_t<SgDefaultOptionStmt,bool,&SgDefaultOptionStmt::p_has_fall_through>>;

};


template <> struct node_from_variant_t<365> { using type = SgDefaultOptionStmt; };


// Class: DefaultSymbol


template <> struct describe_field_t<SgDefaultSymbol,SgType*,&SgDefaultSymbol::p_type> {

  using parent = SgDefaultSymbol;

  using field_type = SgType*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDefaultSymbol::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDefaultSymbol, SgType* SgDefaultSymbol::*, &SgDefaultSymbol::p_type>;

};


template <> struct describe_node_t<SgDefaultSymbol> {

  using node = SgDefaultSymbol;

  using base = SgSymbol;

  static constexpr char const * const name{"DefaultSymbol"};

  static constexpr unsigned long variant{366};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDefaultSymbol,SgType*,&SgDefaultSymbol::p_type>>;

};


template <> struct node_from_variant_t<366> { using type = SgDefaultSymbol; };


// Class: DefineDirectiveStatement


template <> struct describe_node_t<SgDefineDirectiveStatement> {

  using node = SgDefineDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"DefineDirectiveStatement"};

  static constexpr unsigned long variant{367};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<367> { using type = SgDefineDirectiveStatement; };


// Class: DeleteExp


template <> struct describe_field_t<SgDeleteExp,SgExpression*,&SgDeleteExp::p_variable> {

  using parent = SgDeleteExp;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"variable"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDeleteExp::p_variable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeleteExp, SgExpression* SgDeleteExp::*, &SgDeleteExp::p_variable>;

};


template <> struct describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_is_array> {

  using parent = SgDeleteExp;

  using field_type = short;

  static constexpr size_t position{1};

  static constexpr char const * const name{"is_array"};

  static constexpr char const * const typestr{"short"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeleteExp::p_is_array};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeleteExp, short SgDeleteExp::*, &SgDeleteExp::p_is_array>;

};


template <> struct describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_need_global_specifier> {

  using parent = SgDeleteExp;

  using field_type = short;

  static constexpr size_t position{2};

  static constexpr char const * const name{"need_global_specifier"};

  static constexpr char const * const typestr{"short"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeleteExp::p_need_global_specifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeleteExp, short SgDeleteExp::*, &SgDeleteExp::p_need_global_specifier>;

};


template <> struct describe_field_t<SgDeleteExp,SgFunctionDeclaration*,&SgDeleteExp::p_deleteOperatorDeclaration> {

  using parent = SgDeleteExp;

  using field_type = SgFunctionDeclaration*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"deleteOperatorDeclaration"};

  static constexpr char const * const typestr{"SgFunctionDeclaration*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDeleteExp::p_deleteOperatorDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDeleteExp, SgFunctionDeclaration* SgDeleteExp::*, &SgDeleteExp::p_deleteOperatorDeclaration>;

};


template <> struct describe_node_t<SgDeleteExp> {

  using node = SgDeleteExp;

  using base = SgExpression;

  static constexpr char const * const name{"DeleteExp"};

  static constexpr unsigned long variant{368};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDeleteExp,SgExpression*,&SgDeleteExp::p_variable>, describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_is_array>, describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_need_global_specifier>, describe_field_t<SgDeleteExp,SgFunctionDeclaration*,&SgDeleteExp::p_deleteOperatorDeclaration>>;

};


template <> struct node_from_variant_t<368> { using type = SgDeleteExp; };


// Class: DerivedTypeStatement


template <> struct describe_field_t<SgDerivedTypeStatement,SgLabelRefExp*,&SgDerivedTypeStatement::p_end_numeric_label> {

  using parent = SgDerivedTypeStatement;

  using field_type = SgLabelRefExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"end_numeric_label"};

  static constexpr char const * const typestr{"SgLabelRefExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDerivedTypeStatement::p_end_numeric_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDerivedTypeStatement, SgLabelRefExp* SgDerivedTypeStatement::*, &SgDerivedTypeStatement::p_end_numeric_label>;

};


template <> struct describe_node_t<SgDerivedTypeStatement> {

  using node = SgDerivedTypeStatement;

  using base = SgClassDeclaration;

  static constexpr char const * const name{"DerivedTypeStatement"};

  static constexpr unsigned long variant{369};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDerivedTypeStatement,SgLabelRefExp*,&SgDerivedTypeStatement::p_end_numeric_label>>;

};


template <> struct node_from_variant_t<369> { using type = SgDerivedTypeStatement; };


// Class: DesignatedInitializer


template <> struct describe_field_t<SgDesignatedInitializer,SgExprListExp*,&SgDesignatedInitializer::p_designatorList> {

  using parent = SgDesignatedInitializer;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"designatorList"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDesignatedInitializer::p_designatorList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDesignatedInitializer, SgExprListExp* SgDesignatedInitializer::*, &SgDesignatedInitializer::p_designatorList>;

};


template <> struct describe_field_t<SgDesignatedInitializer,SgInitializer*,&SgDesignatedInitializer::p_memberInit> {

  using parent = SgDesignatedInitializer;

  using field_type = SgInitializer*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"memberInit"};

  static constexpr char const * const typestr{"SgInitializer*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDesignatedInitializer::p_memberInit};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDesignatedInitializer, SgInitializer* SgDesignatedInitializer::*, &SgDesignatedInitializer::p_memberInit>;

};


template <> struct describe_node_t<SgDesignatedInitializer> {

  using node = SgDesignatedInitializer;

  using base = SgInitializer;

  static constexpr char const * const name{"DesignatedInitializer"};

  static constexpr unsigned long variant{370};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDesignatedInitializer,SgExprListExp*,&SgDesignatedInitializer::p_designatorList>, describe_field_t<SgDesignatedInitializer,SgInitializer*,&SgDesignatedInitializer::p_memberInit>>;

};


template <> struct node_from_variant_t<370> { using type = SgDesignatedInitializer; };


// Class: DictionaryComprehension


template <> struct describe_field_t<SgDictionaryComprehension,SgKeyDatumPair*,&SgDictionaryComprehension::p_element> {

  using parent = SgDictionaryComprehension;

  using field_type = SgKeyDatumPair*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"element"};

  static constexpr char const * const typestr{"SgKeyDatumPair*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDictionaryComprehension::p_element};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDictionaryComprehension, SgKeyDatumPair* SgDictionaryComprehension::*, &SgDictionaryComprehension::p_element>;

};


template <> struct describe_field_t<SgDictionaryComprehension,SgExprListExp*,&SgDictionaryComprehension::p_generators> {

  using parent = SgDictionaryComprehension;

  using field_type = SgExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"generators"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDictionaryComprehension::p_generators};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDictionaryComprehension, SgExprListExp* SgDictionaryComprehension::*, &SgDictionaryComprehension::p_generators>;

};


template <> struct describe_node_t<SgDictionaryComprehension> {

  using node = SgDictionaryComprehension;

  using base = SgExpression;

  static constexpr char const * const name{"DictionaryComprehension"};

  static constexpr unsigned long variant{371};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDictionaryComprehension,SgKeyDatumPair*,&SgDictionaryComprehension::p_element>, describe_field_t<SgDictionaryComprehension,SgExprListExp*,&SgDictionaryComprehension::p_generators>>;

};


template <> struct node_from_variant_t<371> { using type = SgDictionaryComprehension; };


// Class: DictionaryExp


template <> struct describe_field_t<SgDictionaryExp,SgKeyDatumPairPtrList,&SgDictionaryExp::p_key_datum_pairs> {

  using parent = SgDictionaryExp;

  using field_type = SgKeyDatumPairPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"key_datum_pairs"};

  static constexpr char const * const typestr{"SgKeyDatumPairPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDictionaryExp::p_key_datum_pairs};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDictionaryExp, SgKeyDatumPairPtrList SgDictionaryExp::*, &SgDictionaryExp::p_key_datum_pairs>;

};


template <> struct describe_node_t<SgDictionaryExp> {

  using node = SgDictionaryExp;

  using base = SgExpression;

  static constexpr char const * const name{"DictionaryExp"};

  static constexpr unsigned long variant{372};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDictionaryExp,SgKeyDatumPairPtrList,&SgDictionaryExp::p_key_datum_pairs>>;

};


template <> struct node_from_variant_t<372> { using type = SgDictionaryExp; };


// Class: DimensionObject


template <> struct describe_field_t<SgDimensionObject,SgInitializedName*,&SgDimensionObject::p_array> {

  using parent = SgDimensionObject;

  using field_type = SgInitializedName*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"array"};

  static constexpr char const * const typestr{"SgInitializedName*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDimensionObject::p_array};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDimensionObject, SgInitializedName* SgDimensionObject::*, &SgDimensionObject::p_array>;

};


template <> struct describe_field_t<SgDimensionObject,SgExprListExp*,&SgDimensionObject::p_shape> {

  using parent = SgDimensionObject;

  using field_type = SgExprListExp*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"shape"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDimensionObject::p_shape};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDimensionObject, SgExprListExp* SgDimensionObject::*, &SgDimensionObject::p_shape>;

};


template <> struct describe_node_t<SgDimensionObject> {

  using node = SgDimensionObject;

  using base = SgSupport;

  static constexpr char const * const name{"DimensionObject"};

  static constexpr unsigned long variant{373};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDimensionObject,SgInitializedName*,&SgDimensionObject::p_array>, describe_field_t<SgDimensionObject,SgExprListExp*,&SgDimensionObject::p_shape>>;

};


template <> struct node_from_variant_t<373> { using type = SgDimensionObject; };


// Class: DirectedGraphEdge


template <> struct describe_node_t<SgDirectedGraphEdge> {

  using node = SgDirectedGraphEdge;

  using base = SgGraphEdge;

  static constexpr char const * const name{"DirectedGraphEdge"};

  static constexpr unsigned long variant{375};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<375> { using type = SgDirectedGraphEdge; };


// Class: Directory


template <> struct describe_field_t<SgDirectory,std::string,&SgDirectory::p_name> {

  using parent = SgDirectory;

  using field_type = std::string;

  static constexpr size_t position{0};

  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{&SgDirectory::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDirectory, std::string SgDirectory::*, &SgDirectory::p_name>;

};


template <> struct describe_field_t<SgDirectory,SgFileList*,&SgDirectory::p_fileList> {

  using parent = SgDirectory;

  using field_type = SgFileList*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"fileList"};

  static constexpr char const * const typestr{"SgFileList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDirectory::p_fileList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDirectory, SgFileList* SgDirectory::*, &SgDirectory::p_fileList>;

};


template <> struct describe_field_t<SgDirectory,SgDirectoryList*,&SgDirectory::p_directoryList> {

  using parent = SgDirectory;

  using field_type = SgDirectoryList*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"directoryList"};

  static constexpr char const * const typestr{"SgDirectoryList*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDirectory::p_directoryList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDirectory, SgDirectoryList* SgDirectory::*, &SgDirectory::p_directoryList>;

};


template <> struct describe_field_t<SgDirectory,AstAttributeMechanism*,&SgDirectory::p_attributeMechanism> {

  using parent = SgDirectory;

  using field_type = AstAttributeMechanism*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"attributeMechanism"};

  static constexpr char const * const typestr{"AstAttributeMechanism*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDirectory::p_attributeMechanism};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDirectory, AstAttributeMechanism* SgDirectory::*, &SgDirectory::p_attributeMechanism>;

};


template <> struct describe_node_t<SgDirectory> {

  using node = SgDirectory;

  using base = SgSupport;

  static constexpr char const * const name{"Directory"};

  static constexpr unsigned long variant{377};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDirectory,std::string,&SgDirectory::p_name>, describe_field_t<SgDirectory,SgFileList*,&SgDirectory::p_fileList>, describe_field_t<SgDirectory,SgDirectoryList*,&SgDirectory::p_directoryList>, describe_field_t<SgDirectory,AstAttributeMechanism*,&SgDirectory::p_attributeMechanism>>;

};


template <> struct node_from_variant_t<377> { using type = SgDirectory; };


// Class: DirectoryList


template <> struct describe_field_t<SgDirectoryList,SgDirectoryPtrList,&SgDirectoryList::p_listOfDirectories> {

  using parent = SgDirectoryList;

  using field_type = SgDirectoryPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"listOfDirectories"};

  static constexpr char const * const typestr{"SgDirectoryPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDirectoryList::p_listOfDirectories};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDirectoryList, SgDirectoryPtrList SgDirectoryList::*, &SgDirectoryList::p_listOfDirectories>;

};


template <> struct describe_node_t<SgDirectoryList> {

  using node = SgDirectoryList;

  using base = SgSupport;

  static constexpr char const * const name{"DirectoryList"};

  static constexpr unsigned long variant{378};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDirectoryList,SgDirectoryPtrList,&SgDirectoryList::p_listOfDirectories>>;

};


template <> struct node_from_variant_t<378> { using type = SgDirectoryList; };


// Class: DivAssignOp


template <> struct describe_node_t<SgDivAssignOp> {

  using node = SgDivAssignOp;

  using base = SgCompoundAssignOp;

  static constexpr char const * const name{"DivAssignOp"};

  static constexpr unsigned long variant{379};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<379> { using type = SgDivAssignOp; };


// Class: DivideOp


template <> struct describe_node_t<SgDivideOp> {

  using node = SgDivideOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"DivideOp"};

  static constexpr unsigned long variant{380};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<380> { using type = SgDivideOp; };


// Class: DoWhileStmt


template <> struct describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_body> {

  using parent = SgDoWhileStmt;

  using field_type = SgStatement*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDoWhileStmt::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDoWhileStmt, SgStatement* SgDoWhileStmt::*, &SgDoWhileStmt::p_body>;

};


template <> struct describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_condition> {

  using parent = SgDoWhileStmt;

  using field_type = SgStatement*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"condition"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgDoWhileStmt::p_condition};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDoWhileStmt, SgStatement* SgDoWhileStmt::*, &SgDoWhileStmt::p_condition>;

};


template <> struct describe_node_t<SgDoWhileStmt> {

  using node = SgDoWhileStmt;

  using base = SgScopeStatement;

  static constexpr char const * const name{"DoWhileStmt"};

  static constexpr unsigned long variant{381};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_body>, describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_condition>>;

};


template <> struct node_from_variant_t<381> { using type = SgDoWhileStmt; };


// Class: DotExp


template <> struct describe_node_t<SgDotExp> {

  using node = SgDotExp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"DotExp"};

  static constexpr unsigned long variant{382};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<382> { using type = SgDotExp; };


// Class: DotStarOp


template <> struct describe_node_t<SgDotStarOp> {

  using node = SgDotStarOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"DotStarOp"};

  static constexpr unsigned long variant{383};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<383> { using type = SgDotStarOp; };


// Class: DoubleVal


template <> struct describe_field_t<SgDoubleVal,double,&SgDoubleVal::p_value> {

  using parent = SgDoubleVal;

  using field_type = double;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"double"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgDoubleVal::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDoubleVal, double SgDoubleVal::*, &SgDoubleVal::p_value>;

};


template <> struct describe_field_t<SgDoubleVal,std::string,&SgDoubleVal::p_valueString> {

  using parent = SgDoubleVal;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgDoubleVal::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgDoubleVal, std::string SgDoubleVal::*, &SgDoubleVal::p_valueString>;

};


template <> struct describe_node_t<SgDoubleVal> {

  using node = SgDoubleVal;

  using base = SgValueExp;

  static constexpr char const * const name{"DoubleVal"};

  static constexpr unsigned long variant{384};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgDoubleVal,double,&SgDoubleVal::p_value>, describe_field_t<SgDoubleVal,std::string,&SgDoubleVal::p_valueString>>;

};


template <> struct node_from_variant_t<384> { using type = SgDoubleVal; };


// Class: ElaboratedTypeModifier


template <> struct describe_field_t<SgElaboratedTypeModifier,SgElaboratedTypeModifier::elaborated_type_modifier_enum,&SgElaboratedTypeModifier::p_modifier> {

  using parent = SgElaboratedTypeModifier;

  using field_type = SgElaboratedTypeModifier::elaborated_type_modifier_enum;

  static constexpr size_t position{0};

  static constexpr char const * const name{"modifier"};

  static constexpr char const * const typestr{"SgElaboratedTypeModifier::elaborated_type_modifier_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgElaboratedTypeModifier::p_modifier};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgElaboratedTypeModifier, SgElaboratedTypeModifier::elaborated_type_modifier_enum SgElaboratedTypeModifier::*, &SgElaboratedTypeModifier::p_modifier>;

};


template <> struct describe_node_t<SgElaboratedTypeModifier> {

  using node = SgElaboratedTypeModifier;

  using base = SgModifier;

  static constexpr char const * const name{"ElaboratedTypeModifier"};

  static constexpr unsigned long variant{385};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgElaboratedTypeModifier,SgElaboratedTypeModifier::elaborated_type_modifier_enum,&SgElaboratedTypeModifier::p_modifier>>;

};


template <> struct node_from_variant_t<385> { using type = SgElaboratedTypeModifier; };


// Class: ElementwiseOp


template <> struct describe_node_t<SgElementwiseOp> {

  using node = SgElementwiseOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"ElementwiseOp"};

  static constexpr unsigned long variant{386};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgElementwiseMultiplyOp, SgElementwisePowerOp, SgElementwiseLeftDivideOp, SgElementwiseDivideOp, SgElementwiseAddOp, SgElementwiseSubtractOp>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<386> { using type = SgElementwiseOp; };


// Class: ElementwiseAddOp


template <> struct describe_node_t<SgElementwiseAddOp> {

  using node = SgElementwiseAddOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwiseAddOp"};

  static constexpr unsigned long variant{387};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<387> { using type = SgElementwiseAddOp; };


// Class: ElementwiseDivideOp


template <> struct describe_node_t<SgElementwiseDivideOp> {

  using node = SgElementwiseDivideOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwiseDivideOp"};

  static constexpr unsigned long variant{388};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<388> { using type = SgElementwiseDivideOp; };


// Class: ElementwiseLeftDivideOp


template <> struct describe_node_t<SgElementwiseLeftDivideOp> {

  using node = SgElementwiseLeftDivideOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwiseLeftDivideOp"};

  static constexpr unsigned long variant{389};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<389> { using type = SgElementwiseLeftDivideOp; };


// Class: ElementwiseMultiplyOp


template <> struct describe_node_t<SgElementwiseMultiplyOp> {

  using node = SgElementwiseMultiplyOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwiseMultiplyOp"};

  static constexpr unsigned long variant{390};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<390> { using type = SgElementwiseMultiplyOp; };


// Class: ElementwisePowerOp


template <> struct describe_node_t<SgElementwisePowerOp> {

  using node = SgElementwisePowerOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwisePowerOp"};

  static constexpr unsigned long variant{391};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<391> { using type = SgElementwisePowerOp; };


// Class: ElementwiseSubtractOp


template <> struct describe_node_t<SgElementwiseSubtractOp> {

  using node = SgElementwiseSubtractOp;

  using base = SgElementwiseOp;

  static constexpr char const * const name{"ElementwiseSubtractOp"};

  static constexpr unsigned long variant{392};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<392> { using type = SgElementwiseSubtractOp; };


// Class: ElseDirectiveStatement


template <> struct describe_node_t<SgElseDirectiveStatement> {

  using node = SgElseDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"ElseDirectiveStatement"};

  static constexpr unsigned long variant{393};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<393> { using type = SgElseDirectiveStatement; };


// Class: ElseWhereStatement


template <> struct describe_field_t<SgElseWhereStatement,SgExpression*,&SgElseWhereStatement::p_condition> {

  using parent = SgElseWhereStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"condition"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgElseWhereStatement::p_condition};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgElseWhereStatement, SgExpression* SgElseWhereStatement::*, &SgElseWhereStatement::p_condition>;

};


template <> struct describe_field_t<SgElseWhereStatement,SgBasicBlock*,&SgElseWhereStatement::p_body> {

  using parent = SgElseWhereStatement;

  using field_type = SgBasicBlock*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgBasicBlock*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgElseWhereStatement::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgElseWhereStatement, SgBasicBlock* SgElseWhereStatement::*, &SgElseWhereStatement::p_body>;

};


template <> struct describe_field_t<SgElseWhereStatement,SgElseWhereStatement*,&SgElseWhereStatement::p_elsewhere> {

  using parent = SgElseWhereStatement;

  using field_type = SgElseWhereStatement*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"elsewhere"};

  static constexpr char const * const typestr{"SgElseWhereStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgElseWhereStatement::p_elsewhere};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgElseWhereStatement, SgElseWhereStatement* SgElseWhereStatement::*, &SgElseWhereStatement::p_elsewhere>;

};


template <> struct describe_node_t<SgElseWhereStatement> {

  using node = SgElseWhereStatement;

  using base = SgStatement;

  static constexpr char const * const name{"ElseWhereStatement"};

  static constexpr unsigned long variant{394};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgElseWhereStatement,SgExpression*,&SgElseWhereStatement::p_condition>, describe_field_t<SgElseWhereStatement,SgBasicBlock*,&SgElseWhereStatement::p_body>, describe_field_t<SgElseWhereStatement,SgElseWhereStatement*,&SgElseWhereStatement::p_elsewhere>>;

};


template <> struct node_from_variant_t<394> { using type = SgElseWhereStatement; };


// Class: ElseifDirectiveStatement


template <> struct describe_node_t<SgElseifDirectiveStatement> {

  using node = SgElseifDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"ElseifDirectiveStatement"};

  static constexpr unsigned long variant{395};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<395> { using type = SgElseifDirectiveStatement; };


// Class: EmptyDeclaration


template <> struct describe_node_t<SgEmptyDeclaration> {

  using node = SgEmptyDeclaration;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"EmptyDeclaration"};

  static constexpr unsigned long variant{396};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<396> { using type = SgEmptyDeclaration; };


// Class: EmptyDirectiveStatement


template <> struct describe_node_t<SgEmptyDirectiveStatement> {

  using node = SgEmptyDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"EmptyDirectiveStatement"};

  static constexpr unsigned long variant{397};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<397> { using type = SgEmptyDirectiveStatement; };


// Class: EndfileStatement


template <> struct describe_node_t<SgEndfileStatement> {

  using node = SgEndfileStatement;

  using base = SgIOStatement;

  static constexpr char const * const name{"EndfileStatement"};

  static constexpr unsigned long variant{398};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<398> { using type = SgEndfileStatement; };


// Class: EndifDirectiveStatement


template <> struct describe_node_t<SgEndifDirectiveStatement> {

  using node = SgEndifDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"EndifDirectiveStatement"};

  static constexpr unsigned long variant{399};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<399> { using type = SgEndifDirectiveStatement; };


// Class: EntryStatement


template <> struct describe_field_t<SgEntryStatement,SgInitializedName*,&SgEntryStatement::p_result_name> {

  using parent = SgEntryStatement;

  using field_type = SgInitializedName*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"result_name"};

  static constexpr char const * const typestr{"SgInitializedName*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgEntryStatement::p_result_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEntryStatement, SgInitializedName* SgEntryStatement::*, &SgEntryStatement::p_result_name>;

};


template <> struct describe_node_t<SgEntryStatement> {

  using node = SgEntryStatement;

  using base = SgFunctionDeclaration;

  static constexpr char const * const name{"EntryStatement"};

  static constexpr unsigned long variant{400};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEntryStatement,SgInitializedName*,&SgEntryStatement::p_result_name>>;

};


template <> struct node_from_variant_t<400> { using type = SgEntryStatement; };


// Class: EnumDeclaration


template <> struct describe_field_t<SgEnumDeclaration,SgName,&SgEnumDeclaration::p_name> {

  using parent = SgEnumDeclaration;

  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{&SgEnumDeclaration::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgName SgEnumDeclaration::*, &SgEnumDeclaration::p_name>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_embedded> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{1};

  static constexpr char const * const name{"embedded"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_embedded};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_embedded>;

};


template <> struct describe_field_t<SgEnumDeclaration,SgEnumType*,&SgEnumDeclaration::p_type> {

  using parent = SgEnumDeclaration;

  using field_type = SgEnumType*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"type"};

  static constexpr char const * const typestr{"SgEnumType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgEnumType* SgEnumDeclaration::*, &SgEnumDeclaration::p_type>;

};


template <> struct describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_adaParentType> {

  using parent = SgEnumDeclaration;

  using field_type = SgType*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"adaParentType"};

  static constexpr char const * const typestr{"SgType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_adaParentType};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgType* SgEnumDeclaration::*, &SgEnumDeclaration::p_adaParentType>;

};


template <> struct describe_field_t<SgEnumDeclaration,SgInitializedNamePtrList,&SgEnumDeclaration::p_enumerators> {

  using parent = SgEnumDeclaration;

  using field_type = SgInitializedNamePtrList;

  static constexpr size_t position{4};

  static constexpr char const * const name{"enumerators"};

  static constexpr char const * const typestr{"SgInitializedNamePtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_enumerators};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgInitializedNamePtrList SgEnumDeclaration::*, &SgEnumDeclaration::p_enumerators>;

};


template <> struct describe_field_t<SgEnumDeclaration,SgScopeStatement*,&SgEnumDeclaration::p_scope> {

  using parent = SgEnumDeclaration;

  using field_type = SgScopeStatement*;

  static constexpr size_t position{5};

  static constexpr char const * const name{"scope"};

  static constexpr char const * const typestr{"SgScopeStatement*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_scope};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgScopeStatement* SgEnumDeclaration::*, &SgEnumDeclaration::p_scope>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isUnNamed> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"isUnNamed"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isUnNamed};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isUnNamed>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isAutonomousDeclaration> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"isAutonomousDeclaration"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isAutonomousDeclaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isAutonomousDeclaration>;

};


template <> struct describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_field_type> {

  using parent = SgEnumDeclaration;

  using field_type = SgType*;

  static constexpr size_t position{8};

  static constexpr char const * const name{"field_type"};

  static constexpr char const * const typestr{"SgType*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_field_type};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, SgType* SgEnumDeclaration::*, &SgEnumDeclaration::p_field_type>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isScopedEnum> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{9};

  static constexpr char const * const name{"isScopedEnum"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isScopedEnum};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isScopedEnum>;

};


template <> struct describe_field_t<SgEnumDeclaration,int,&SgEnumDeclaration::p_name_qualification_length> {

  using parent = SgEnumDeclaration;

  using field_type = int;

  static constexpr size_t position{10};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, int SgEnumDeclaration::*, &SgEnumDeclaration::p_name_qualification_length>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_type_elaboration_required> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{11};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_global_qualification_required> {

  using parent = SgEnumDeclaration;

  using field_type = bool;

  static constexpr size_t position{12};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumDeclaration::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_global_qualification_required>;

};


template <> struct describe_node_t<SgEnumDeclaration> {

  using node = SgEnumDeclaration;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"EnumDeclaration"};

  static constexpr unsigned long variant{401};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEnumDeclaration,SgName,&SgEnumDeclaration::p_name>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_embedded>, describe_field_t<SgEnumDeclaration,SgEnumType*,&SgEnumDeclaration::p_type>, describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_adaParentType>, describe_field_t<SgEnumDeclaration,SgInitializedNamePtrList,&SgEnumDeclaration::p_enumerators>, describe_field_t<SgEnumDeclaration,SgScopeStatement*,&SgEnumDeclaration::p_scope>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isUnNamed>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isAutonomousDeclaration>, describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_field_type>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isScopedEnum>, describe_field_t<SgEnumDeclaration,int,&SgEnumDeclaration::p_name_qualification_length>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_type_elaboration_required>, describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_global_qualification_required>>;

};


template <> struct node_from_variant_t<401> { using type = SgEnumDeclaration; };


// Class: EnumFieldSymbol


template <> struct describe_field_t<SgEnumFieldSymbol,SgInitializedName*,&SgEnumFieldSymbol::p_declaration> {

  using parent = SgEnumFieldSymbol;

  using field_type = SgInitializedName*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgInitializedName*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumFieldSymbol::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumFieldSymbol, SgInitializedName* SgEnumFieldSymbol::*, &SgEnumFieldSymbol::p_declaration>;

};


template <> struct describe_node_t<SgEnumFieldSymbol> {

  using node = SgEnumFieldSymbol;

  using base = SgSymbol;

  static constexpr char const * const name{"EnumFieldSymbol"};

  static constexpr unsigned long variant{402};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEnumFieldSymbol,SgInitializedName*,&SgEnumFieldSymbol::p_declaration>>;

};


template <> struct node_from_variant_t<402> { using type = SgEnumFieldSymbol; };


// Class: EnumSymbol


template <> struct describe_field_t<SgEnumSymbol,SgEnumDeclaration*,&SgEnumSymbol::p_declaration> {

  using parent = SgEnumSymbol;

  using field_type = SgEnumDeclaration*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgEnumDeclaration*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgEnumSymbol::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumSymbol, SgEnumDeclaration* SgEnumSymbol::*, &SgEnumSymbol::p_declaration>;

};


template <> struct describe_node_t<SgEnumSymbol> {

  using node = SgEnumSymbol;

  using base = SgTypeSymbol;

  static constexpr char const * const name{"EnumSymbol"};

  static constexpr unsigned long variant{403};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEnumSymbol,SgEnumDeclaration*,&SgEnumSymbol::p_declaration>>;

};


template <> struct node_from_variant_t<403> { using type = SgEnumSymbol; };


// Class: EnumType


template <> struct describe_node_t<SgEnumType> {

  using node = SgEnumType;

  using base = SgNamedType;

  static constexpr char const * const name{"EnumType"};

  static constexpr unsigned long variant{404};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<404> { using type = SgEnumType; };


// Class: EnumVal


template <> struct describe_field_t<SgEnumVal,long long int,&SgEnumVal::p_value> {

  using parent = SgEnumVal;

  using field_type = long long int;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"long long int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, long long int SgEnumVal::*, &SgEnumVal::p_value>;

};


template <> struct describe_field_t<SgEnumVal,SgEnumDeclaration*,&SgEnumVal::p_declaration> {

  using parent = SgEnumVal;

  using field_type = SgEnumDeclaration*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"declaration"};

  static constexpr char const * const typestr{"SgEnumDeclaration*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_declaration};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, SgEnumDeclaration* SgEnumVal::*, &SgEnumVal::p_declaration>;

};


template <> struct describe_field_t<SgEnumVal,SgName,&SgEnumVal::p_name> {

  using parent = SgEnumVal;

  using field_type = SgName;

  static constexpr size_t position{2};

  static constexpr char const * const name{"name"};

  static constexpr char const * const typestr{"SgName"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, SgName SgEnumVal::*, &SgEnumVal::p_name>;

};


template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_requiresNameQualification> {

  using parent = SgEnumVal;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"requiresNameQualification"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_requiresNameQualification};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_requiresNameQualification>;

};


template <> struct describe_field_t<SgEnumVal,int,&SgEnumVal::p_name_qualification_length> {

  using parent = SgEnumVal;

  using field_type = int;

  static constexpr size_t position{4};

  static constexpr char const * const name{"name_qualification_length"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_name_qualification_length};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, int SgEnumVal::*, &SgEnumVal::p_name_qualification_length>;

};


template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_type_elaboration_required> {

  using parent = SgEnumVal;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"type_elaboration_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_type_elaboration_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_type_elaboration_required>;

};


template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_global_qualification_required> {

  using parent = SgEnumVal;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"global_qualification_required"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEnumVal::p_global_qualification_required};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_global_qualification_required>;

};


template <> struct describe_node_t<SgEnumVal> {

  using node = SgEnumVal;

  using base = SgValueExp;

  static constexpr char const * const name{"EnumVal"};

  static constexpr unsigned long variant{405};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEnumVal,long long int,&SgEnumVal::p_value>, describe_field_t<SgEnumVal,SgEnumDeclaration*,&SgEnumVal::p_declaration>, describe_field_t<SgEnumVal,SgName,&SgEnumVal::p_name>, describe_field_t<SgEnumVal,bool,&SgEnumVal::p_requiresNameQualification>, describe_field_t<SgEnumVal,int,&SgEnumVal::p_name_qualification_length>, describe_field_t<SgEnumVal,bool,&SgEnumVal::p_type_elaboration_required>, describe_field_t<SgEnumVal,bool,&SgEnumVal::p_global_qualification_required>>;

};


template <> struct node_from_variant_t<405> { using type = SgEnumVal; };


// Class: EqualityOp


template <> struct describe_node_t<SgEqualityOp> {

  using node = SgEqualityOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"EqualityOp"};

  static constexpr unsigned long variant{406};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<406> { using type = SgEqualityOp; };


// Class: EquivalenceStatement


template <> struct describe_field_t<SgEquivalenceStatement,SgExprListExp*,&SgEquivalenceStatement::p_equivalence_set_list> {

  using parent = SgEquivalenceStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"equivalence_set_list"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgEquivalenceStatement::p_equivalence_set_list};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgEquivalenceStatement, SgExprListExp* SgEquivalenceStatement::*, &SgEquivalenceStatement::p_equivalence_set_list>;

};


template <> struct describe_node_t<SgEquivalenceStatement> {

  using node = SgEquivalenceStatement;

  using base = SgDeclarationStatement;

  static constexpr char const * const name{"EquivalenceStatement"};

  static constexpr unsigned long variant{407};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgEquivalenceStatement,SgExprListExp*,&SgEquivalenceStatement::p_equivalence_set_list>>;

};


template <> struct node_from_variant_t<407> { using type = SgEquivalenceStatement; };


// Class: ErrorDirectiveStatement


template <> struct describe_node_t<SgErrorDirectiveStatement> {

  using node = SgErrorDirectiveStatement;

  using base = SgC_PreprocessorDirectiveStatement;

  static constexpr char const * const name{"ErrorDirectiveStatement"};

  static constexpr unsigned long variant{408};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<408> { using type = SgErrorDirectiveStatement; };


// Class: ExecStatement


template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_executable> {

  using parent = SgExecStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"executable"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExecStatement::p_executable};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_executable>;

};


template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_globals> {

  using parent = SgExecStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"globals"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExecStatement::p_globals};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_globals>;

};


template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_locals> {

  using parent = SgExecStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"locals"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExecStatement::p_locals};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_locals>;

};


template <> struct describe_node_t<SgExecStatement> {

  using node = SgExecStatement;

  using base = SgStatement;

  static constexpr char const * const name{"ExecStatement"};

  static constexpr unsigned long variant{409};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_executable>, describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_globals>, describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_locals>>;

};


template <> struct node_from_variant_t<409> { using type = SgExecStatement; };


// Class: ExponentiationOp


template <> struct describe_node_t<SgExponentiationOp> {

  using node = SgExponentiationOp;

  using base = SgBinaryOp;

  static constexpr char const * const name{"ExponentiationOp"};

  static constexpr unsigned long variant{410};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<410> { using type = SgExponentiationOp; };


// Class: ExponentiationAssignOp


template <> struct describe_node_t<SgExponentiationAssignOp> {

  using node = SgExponentiationAssignOp;

  using base = SgCompoundAssignOp;

  static constexpr char const * const name{"ExponentiationAssignOp"};

  static constexpr unsigned long variant{411};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<411> { using type = SgExponentiationAssignOp; };


// Class: ExprListExp


template <> struct describe_field_t<SgExprListExp,SgExpressionPtrList,&SgExprListExp::p_expressions> {

  using parent = SgExprListExp;

  using field_type = SgExpressionPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"expressions"};

  static constexpr char const * const typestr{"SgExpressionPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExprListExp::p_expressions};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExprListExp, SgExpressionPtrList SgExprListExp::*, &SgExprListExp::p_expressions>;

};


template <> struct describe_node_t<SgExprListExp> {

  using node = SgExprListExp;

  using base = SgExpression;

  static constexpr char const * const name{"ExprListExp"};

  static constexpr unsigned long variant{412};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<SgListExp, SgTupleExp, SgMatrixExp>;

  using fields_t = mp::List<describe_field_t<SgExprListExp,SgExpressionPtrList,&SgExprListExp::p_expressions>>;

};


template <> struct node_from_variant_t<412> { using type = SgExprListExp; };


// Class: ExprStatement


template <> struct describe_field_t<SgExprStatement,SgExpression*,&SgExprStatement::p_expression> {

  using parent = SgExprStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"expression"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgExprStatement::p_expression};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExprStatement, SgExpression* SgExprStatement::*, &SgExprStatement::p_expression>;

};


template <> struct describe_node_t<SgExprStatement> {

  using node = SgExprStatement;

  using base = SgStatement;

  static constexpr char const * const name{"ExprStatement"};

  static constexpr unsigned long variant{413};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgExprStatement,SgExpression*,&SgExprStatement::p_expression>>;

};


template <> struct node_from_variant_t<413> { using type = SgExprStatement; };


// Class: Expression


template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_need_paren> {

  using parent = SgExpression;

  using field_type = bool;

  static constexpr size_t position{0};

  static constexpr char const * const name{"need_paren"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgExpression::p_need_paren};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_need_paren>;

};


template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_lvalue> {

  using parent = SgExpression;

  using field_type = bool;

  static constexpr size_t position{1};

  static constexpr char const * const name{"lvalue"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgExpression::p_lvalue};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_lvalue>;

};


template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_global_qualified_name> {

  using parent = SgExpression;

  using field_type = bool;

  static constexpr size_t position{2};

  static constexpr char const * const name{"global_qualified_name"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgExpression::p_global_qualified_name};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_global_qualified_name>;

};


template <> struct describe_field_t<SgExpression,Sg_File_Info*,&SgExpression::p_operatorPosition> {

  using parent = SgExpression;

  using field_type = Sg_File_Info*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"operatorPosition"};

  static constexpr char const * const typestr{"Sg_File_Info*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgExpression::p_operatorPosition};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgExpression, Sg_File_Info* SgExpression::*, &SgExpression::p_operatorPosition>;

};


template <> struct describe_node_t<SgExpression> {

  using node = SgExpression;

  using base = SgLocatedNode;

  static constexpr char const * const name{"Expression"};

  static constexpr unsigned long variant{414};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgUnaryOp, SgBinaryOp, SgExprListExp, SgValueExp, SgCallExpression, SgUpcLocalsizeofExpression, SgUpcBlocksizeofExpression, SgUpcElemsizeofExpression, SgJavaInstanceOfOp, SgSuperExp, SgTypeIdOp, SgConditionalExp, SgNewExp, SgDeleteExp, SgThisExp, SgRefExp, SgInitializer, SgVarArgStartOp, SgVarArgOp, SgVarArgEndOp, SgVarArgCopyOp, SgVarArgStartOneOperandOp, SgNullExpression, SgVariantExpression, SgSubscriptExpression, SgColonShapeExp, SgAsteriskShapeExp, SgImpliedDo, SgIOItemExpression, SgActualArgumentExpression, SgStatementExpression, SgAsmOp, SgCudaKernelExecConfig, SgUnknownArrayOrFunctionReference, SgPseudoDestructorRefExp, SgCAFCoExpression, SgSizeOfOp, SgLambdaRefExp, SgDictionaryExp, SgKeyDatumPair, SgReferenceExp, SgComprehension, SgListComprehension, SgSetComprehension, SgDictionaryComprehension, SgNaryOp, SgStringConversion, SgYieldExpression, SgAlignOfOp, SgRangeExp, SgMagicColonExp, SgTypeTraitBuiltinOperator, SgCompoundLiteralExp, SgJavaAnnotation, SgJavaTypeExpression, SgTypeExpression, SgClassExp, SgFunctionParameterRefExp, SgLambdaExp, SgHereExp, SgAtExp, SgFinishExp, SgNoexceptOp, SgAdaTaskRefExp, SgAdaProtectedRefExp, SgFoldExpression, SgAwaitExpression, SgChooseExpression, SgAdaAttributeExp, SgJovialTablePresetExp, SgJovialPresetPositionExp, SgAdaOthersExp, SgAdaRenamingRefExp, SgAdaUnitRefExp>;

  using fields_t = mp::List<describe_field_t<SgExpression,bool,&SgExpression::p_need_paren>, describe_field_t<SgExpression,bool,&SgExpression::p_lvalue>, describe_field_t<SgExpression,bool,&SgExpression::p_global_qualified_name>, describe_field_t<SgExpression,Sg_File_Info*,&SgExpression::p_operatorPosition>>;

};


template <> struct node_from_variant_t<414> { using type = SgExpression; };


// Class: ExpressionRoot


template <> struct describe_node_t<SgExpressionRoot> {

  using node = SgExpressionRoot;

  using base = SgUnaryOp;

  static constexpr char const * const name{"ExpressionRoot"};

  static constexpr unsigned long variant{415};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<415> { using type = SgExpressionRoot; };


// Class: File


template <> struct describe_field_t<SgFile,Sg_File_Info*,&SgFile::p_startOfConstruct> {

  using parent = SgFile;

  using field_type = Sg_File_Info*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"startOfConstruct"};

  static constexpr char const * const typestr{"Sg_File_Info*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_startOfConstruct};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, Sg_File_Info* SgFile::*, &SgFile::p_startOfConstruct>;

};


template <> struct describe_field_t<SgFile,SgStringList,&SgFile::p_originalCommandLineArgumentList> {

  using parent = SgFile;

  using field_type = SgStringList;

  static constexpr size_t position{1};

  static constexpr char const * const name{"originalCommandLineArgumentList"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_originalCommandLineArgumentList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgStringList SgFile::*, &SgFile::p_originalCommandLineArgumentList>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_verbose> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{2};

  static constexpr char const * const name{"verbose"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_verbose};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_verbose>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_output_warnings> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{3};

  static constexpr char const * const name{"output_warnings"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_output_warnings};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_output_warnings>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_C_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{4};

  static constexpr char const * const name{"C_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_C_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_C_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Cxx_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{5};

  static constexpr char const * const name{"Cxx_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Cxx_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Cxx_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Fortran_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{6};

  static constexpr char const * const name{"Fortran_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Fortran_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Fortran_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_CoArrayFortran_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{7};

  static constexpr char const * const name{"CoArrayFortran_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_CoArrayFortran_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_CoArrayFortran_only>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_upc_threads> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{8};

  static constexpr char const * const name{"upc_threads"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_upc_threads};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_upc_threads>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Java_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{9};

  static constexpr char const * const name{"Java_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Java_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Java_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Jvm_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{10};

  static constexpr char const * const name{"Jvm_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Jvm_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Jvm_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Jovial_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{11};

  static constexpr char const * const name{"Jovial_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Jovial_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Jovial_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_PHP_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{12};

  static constexpr char const * const name{"PHP_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_PHP_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_PHP_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Python_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{13};

  static constexpr char const * const name{"Python_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Python_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Python_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Cuda_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{14};

  static constexpr char const * const name{"Cuda_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Cuda_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Cuda_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_OpenCL_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{15};

  static constexpr char const * const name{"OpenCL_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_OpenCL_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_OpenCL_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Csharp_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{16};

  static constexpr char const * const name{"Csharp_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Csharp_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Csharp_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_Ada_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{17};

  static constexpr char const * const name{"Ada_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_Ada_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Ada_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_requires_C_preprocessor> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{18};

  static constexpr char const * const name{"requires_C_preprocessor"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_requires_C_preprocessor};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_requires_C_preprocessor>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_binary_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{19};

  static constexpr char const * const name{"binary_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_binary_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_binary_only>;

};


template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_inputFormat> {

  using parent = SgFile;

  using field_type = SgFile::outputFormatOption_enum;

  static constexpr size_t position{20};

  static constexpr char const * const name{"inputFormat"};

  static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_inputFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_inputFormat>;

};


template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_outputFormat> {

  using parent = SgFile;

  using field_type = SgFile::outputFormatOption_enum;

  static constexpr size_t position{21};

  static constexpr char const * const name{"outputFormat"};

  static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_outputFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_outputFormat>;

};


template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_backendCompileFormat> {

  using parent = SgFile;

  using field_type = SgFile::outputFormatOption_enum;

  static constexpr size_t position{22};

  static constexpr char const * const name{"backendCompileFormat"};

  static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_backendCompileFormat};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_backendCompileFormat>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_fortran_implicit_none> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{23};

  static constexpr char const * const name{"fortran_implicit_none"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_fortran_implicit_none};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_fortran_implicit_none>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{24};

  static constexpr char const * const name{"openmp"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openmp};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_parse_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{25};

  static constexpr char const * const name{"openmp_parse_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openmp_parse_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_parse_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_ast_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{26};

  static constexpr char const * const name{"openmp_ast_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openmp_ast_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_ast_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_lowering> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{27};

  static constexpr char const * const name{"openmp_lowering"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openmp_lowering};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_lowering>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{28};

  static constexpr char const * const name{"openacc"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openacc};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc_parse_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{29};

  static constexpr char const * const name{"openacc_parse_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openacc_parse_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc_parse_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc_ast_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{30};

  static constexpr char const * const name{"openacc_ast_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_openacc_ast_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc_ast_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_cray_pointer_support> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{31};

  static constexpr char const * const name{"cray_pointer_support"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_cray_pointer_support};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_cray_pointer_support>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_failsafe> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{32};

  static constexpr char const * const name{"failsafe"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_failsafe};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_failsafe>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_output_parser_actions> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{33};

  static constexpr char const * const name{"output_parser_actions"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_output_parser_actions};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_output_parser_actions>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_exit_after_parser> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{34};

  static constexpr char const * const name{"exit_after_parser"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_exit_after_parser};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_exit_after_parser>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_syntax_check> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{35};

  static constexpr char const * const name{"skip_syntax_check"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_syntax_check};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_syntax_check>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_parser> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{36};

  static constexpr char const * const name{"skip_parser"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_parser};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_parser>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_relax_syntax_check> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{37};

  static constexpr char const * const name{"relax_syntax_check"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_relax_syntax_check};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_relax_syntax_check>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_translation_from_edg_ast_to_rose_ast> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{38};

  static constexpr char const * const name{"skip_translation_from_edg_ast_to_rose_ast"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_translation_from_edg_ast_to_rose_ast};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_translation_from_edg_ast_to_rose_ast>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_transformation> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{39};

  static constexpr char const * const name{"skip_transformation"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_transformation};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_transformation>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_unparse> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{40};

  static constexpr char const * const name{"skip_unparse"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_unparse};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_unparse>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skipfinalCompileStep> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{41};

  static constexpr char const * const name{"skipfinalCompileStep"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skipfinalCompileStep};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skipfinalCompileStep>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_includes> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{42};

  static constexpr char const * const name{"unparse_includes"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_includes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_includes>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_line_directives> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{43};

  static constexpr char const * const name{"unparse_line_directives"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_line_directives};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_line_directives>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_syntax> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{44};

  static constexpr char const * const name{"unparse_function_calls_using_operator_syntax"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_function_calls_using_operator_syntax};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_function_calls_using_operator_syntax>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_names> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{45};

  static constexpr char const * const name{"unparse_function_calls_using_operator_names"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_function_calls_using_operator_names};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_function_calls_using_operator_names>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_instruction_addresses> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{46};

  static constexpr char const * const name{"unparse_instruction_addresses"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_instruction_addresses};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_instruction_addresses>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_raw_memory_contents> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{47};

  static constexpr char const * const name{"unparse_raw_memory_contents"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_raw_memory_contents};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_raw_memory_contents>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_binary_file_format> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{48};

  static constexpr char const * const name{"unparse_binary_file_format"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_binary_file_format};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_binary_file_format>;

};


template <> struct describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_outputLanguage> {

  using parent = SgFile;

  using field_type = SgFile::languageOption_enum;

  static constexpr size_t position{49};

  static constexpr char const * const name{"outputLanguage"};

  static constexpr char const * const typestr{"SgFile::languageOption_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_outputLanguage};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::languageOption_enum SgFile::*, &SgFile::p_outputLanguage>;

};


template <> struct describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_inputLanguage> {

  using parent = SgFile;

  using field_type = SgFile::languageOption_enum;

  static constexpr size_t position{50};

  static constexpr char const * const name{"inputLanguage"};

  static constexpr char const * const typestr{"SgFile::languageOption_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_inputLanguage};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::languageOption_enum SgFile::*, &SgFile::p_inputLanguage>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithPath> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{51};

  static constexpr char const * const name{"sourceFileNameWithPath"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileNameWithPath};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_sourceFileNameWithPath>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithoutPath> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{52};

  static constexpr char const * const name{"sourceFileNameWithoutPath"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileNameWithoutPath};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_sourceFileNameWithoutPath>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_unparse_output_filename> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{53};

  static constexpr char const * const name{"unparse_output_filename"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_output_filename};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_unparse_output_filename>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithPath> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{54};

  static constexpr char const * const name{"objectFileNameWithPath"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_objectFileNameWithPath};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_objectFileNameWithPath>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithoutPath> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{55};

  static constexpr char const * const name{"objectFileNameWithoutPath"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_objectFileNameWithoutPath};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_objectFileNameWithoutPath>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_useBackendOnly> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{56};

  static constexpr char const * const name{"useBackendOnly"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_useBackendOnly};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_useBackendOnly>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_compileOnly> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{57};

  static constexpr char const * const name{"compileOnly"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_compileOnly};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_compileOnly>;

};


template <> struct describe_field_t<SgFile,std::string,&SgFile::p_savedFrontendCommandLine> {

  using parent = SgFile;

  using field_type = std::string;

  static constexpr size_t position{58};

  static constexpr char const * const name{"savedFrontendCommandLine"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_savedFrontendCommandLine};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_savedFrontendCommandLine>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_implicit_templates> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{59};

  static constexpr char const * const name{"no_implicit_templates"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_no_implicit_templates};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_implicit_templates>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_implicit_inline_templates> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{60};

  static constexpr char const * const name{"no_implicit_inline_templates"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_no_implicit_inline_templates};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_implicit_inline_templates>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_commentsAndDirectives> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{61};

  static constexpr char const * const name{"skip_commentsAndDirectives"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skip_commentsAndDirectives};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_commentsAndDirectives>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_collectAllCommentsAndDirectives> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{62};

  static constexpr char const * const name{"collectAllCommentsAndDirectives"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_collectAllCommentsAndDirectives};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_collectAllCommentsAndDirectives>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_translateCommentsAndDirectivesIntoAST> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{63};

  static constexpr char const * const name{"translateCommentsAndDirectivesIntoAST"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_translateCommentsAndDirectivesIntoAST};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_translateCommentsAndDirectivesIntoAST>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparseHeaderFiles> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{64};

  static constexpr char const * const name{"unparseHeaderFiles"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparseHeaderFiles};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparseHeaderFiles>;

};


template <> struct describe_field_t<SgFile,ROSEAttributesListContainerPtr,&SgFile::p_preprocessorDirectivesAndCommentsList> {

  using parent = SgFile;

  using field_type = ROSEAttributesListContainerPtr;

  static constexpr size_t position{65};

  static constexpr char const * const name{"preprocessorDirectivesAndCommentsList"};

  static constexpr char const * const typestr{"ROSEAttributesListContainerPtr"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_preprocessorDirectivesAndCommentsList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, ROSEAttributesListContainerPtr SgFile::*, &SgFile::p_preprocessorDirectivesAndCommentsList>;

};


template <> struct describe_field_t<SgFile,AstAttributeMechanism*,&SgFile::p_attributeMechanism> {

  using parent = SgFile;

  using field_type = AstAttributeMechanism*;

  static constexpr size_t position{66};

  static constexpr char const * const name{"attributeMechanism"};

  static constexpr char const * const typestr{"AstAttributeMechanism*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_attributeMechanism};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, AstAttributeMechanism* SgFile::*, &SgFile::p_attributeMechanism>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_KCC_frontend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{67};

  static constexpr char const * const name{"KCC_frontend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_KCC_frontend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_KCC_frontend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_new_frontend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{68};

  static constexpr char const * const name{"new_frontend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_new_frontend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_new_frontend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_disable_edg_backend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{69};

  static constexpr char const * const name{"disable_edg_backend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_disable_edg_backend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_disable_edg_backend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_disable_sage_backend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{70};

  static constexpr char const * const name{"disable_sage_backend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_disable_sage_backend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_disable_sage_backend>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_testingLevel> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{71};

  static constexpr char const * const name{"testingLevel"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_testingLevel};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_testingLevel>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_preinit_il> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{72};

  static constexpr char const * const name{"preinit_il"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_preinit_il};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_preinit_il>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_enable_cp_backend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{73};

  static constexpr char const * const name{"enable_cp_backend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_enable_cp_backend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_enable_cp_backend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_markGeneratedFiles> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{74};

  static constexpr char const * const name{"markGeneratedFiles"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_markGeneratedFiles};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_markGeneratedFiles>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_negative_test> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{75};

  static constexpr char const * const name{"negative_test"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_negative_test};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_negative_test>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_strict_language_handling> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{76};

  static constexpr char const * const name{"strict_language_handling"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_strict_language_handling};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_strict_language_handling>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_wave> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{77};

  static constexpr char const * const name{"wave"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_wave};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_wave>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_embedColorCodesInGeneratedCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{78};

  static constexpr char const * const name{"embedColorCodesInGeneratedCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_embedColorCodesInGeneratedCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_embedColorCodesInGeneratedCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_generateSourcePositionCodes> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{79};

  static constexpr char const * const name{"generateSourcePositionCodes"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_generateSourcePositionCodes};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_generateSourcePositionCodes>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCppFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{80};

  static constexpr char const * const name{"sourceFileUsesCppFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCppFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCppFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortranFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{81};

  static constexpr char const * const name{"sourceFileUsesFortranFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortranFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortranFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran77FileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{82};

  static constexpr char const * const name{"sourceFileUsesFortran77FileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran77FileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran77FileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran90FileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{83};

  static constexpr char const * const name{"sourceFileUsesFortran90FileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran90FileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran90FileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran95FileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{84};

  static constexpr char const * const name{"sourceFileUsesFortran95FileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran95FileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran95FileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2003FileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{85};

  static constexpr char const * const name{"sourceFileUsesFortran2003FileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran2003FileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran2003FileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2008FileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{86};

  static constexpr char const * const name{"sourceFileUsesFortran2008FileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran2008FileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran2008FileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCoArrayFortranFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{87};

  static constexpr char const * const name{"sourceFileUsesCoArrayFortranFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCoArrayFortranFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCoArrayFortranFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPHPFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{88};

  static constexpr char const * const name{"sourceFileUsesPHPFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesPHPFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesPHPFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPythonFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{89};

  static constexpr char const * const name{"sourceFileUsesPythonFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesPythonFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesPythonFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJavaFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{90};

  static constexpr char const * const name{"sourceFileUsesJavaFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJavaFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJavaFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJvmFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{91};

  static constexpr char const * const name{"sourceFileUsesJvmFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJvmFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJvmFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesBinaryFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{92};

  static constexpr char const * const name{"sourceFileUsesBinaryFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesBinaryFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesBinaryFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileTypeIsUnknown> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{93};

  static constexpr char const * const name{"sourceFileTypeIsUnknown"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileTypeIsUnknown};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileTypeIsUnknown>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCsharpFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{94};

  static constexpr char const * const name{"sourceFileUsesCsharpFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCsharpFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCsharpFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesAdaFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{95};

  static constexpr char const * const name{"sourceFileUsesAdaFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesAdaFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesAdaFileExtension>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJovialFileExtension> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{96};

  static constexpr char const * const name{"sourceFileUsesJovialFileExtension"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJovialFileExtension};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJovialFileExtension>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_detect_dangling_pointers> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{97};

  static constexpr char const * const name{"detect_dangling_pointers"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_detect_dangling_pointers};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_detect_dangling_pointers>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_experimental_flang_frontend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{98};

  static constexpr char const * const name{"experimental_flang_frontend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_experimental_flang_frontend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_experimental_flang_frontend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_read_executable_file_format_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{99};

  static constexpr char const * const name{"read_executable_file_format_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_read_executable_file_format_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_read_executable_file_format_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_visualize_executable_file_format_skip_symbols> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{100};

  static constexpr char const * const name{"visualize_executable_file_format_skip_symbols"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_visualize_executable_file_format_skip_symbols};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_visualize_executable_file_format_skip_symbols>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_visualize_dwarf_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{101};

  static constexpr char const * const name{"visualize_dwarf_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_visualize_dwarf_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_visualize_dwarf_only>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_read_instructions_only> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{102};

  static constexpr char const * const name{"read_instructions_only"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_read_instructions_only};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_read_instructions_only>;

};


template <> struct describe_field_t<SgFile,SgStringList,&SgFile::p_libraryArchiveObjectFileNameList> {

  using parent = SgFile;

  using field_type = SgStringList;

  static constexpr size_t position{103};

  static constexpr char const * const name{"libraryArchiveObjectFileNameList"};

  static constexpr char const * const typestr{"SgStringList"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_libraryArchiveObjectFileNameList};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgStringList SgFile::*, &SgFile::p_libraryArchiveObjectFileNameList>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_isLibraryArchive> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{104};

  static constexpr char const * const name{"isLibraryArchive"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_isLibraryArchive};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_isLibraryArchive>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_isObjectFile> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{105};

  static constexpr char const * const name{"isObjectFile"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_isObjectFile};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_isObjectFile>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_tokens> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{106};

  static constexpr char const * const name{"unparse_tokens"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_tokens};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_tokens>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_unparse_tokens_testing> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{107};

  static constexpr char const * const name{"unparse_tokens_testing"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_tokens_testing};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_unparse_tokens_testing>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_using_leading_and_trailing_token_mappings> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{108};

  static constexpr char const * const name{"unparse_using_leading_and_trailing_token_mappings"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_using_leading_and_trailing_token_mappings};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_using_leading_and_trailing_token_mappings>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_template_ast> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{109};

  static constexpr char const * const name{"unparse_template_ast"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_template_ast};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_template_ast>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_skipAstConsistancyTests> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{110};

  static constexpr char const * const name{"skipAstConsistancyTests"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_skipAstConsistancyTests};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skipAstConsistancyTests>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_multifile_support> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{111};

  static constexpr char const * const name{"multifile_support"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_multifile_support};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_multifile_support>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_optimization> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{112};

  static constexpr char const * const name{"optimization"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_optimization};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_optimization>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_use_token_stream_to_improve_source_position_info> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{113};

  static constexpr char const * const name{"use_token_stream_to_improve_source_position_info"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_use_token_stream_to_improve_source_position_info};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_use_token_stream_to_improve_source_position_info>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_suppress_variable_declaration_normalization> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{114};

  static constexpr char const * const name{"suppress_variable_declaration_normalization"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_suppress_variable_declaration_normalization};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_suppress_variable_declaration_normalization>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_edg_il_to_graphviz> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{115};

  static constexpr char const * const name{"edg_il_to_graphviz"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_edg_il_to_graphviz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_edg_il_to_graphviz>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_clang_il_to_graphviz> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{116};

  static constexpr char const * const name{"clang_il_to_graphviz"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_clang_il_to_graphviz};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_clang_il_to_graphviz>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_optimize_flag_for_frontend> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{117};

  static constexpr char const * const name{"no_optimize_flag_for_frontend"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_no_optimize_flag_for_frontend};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_optimize_flag_for_frontend>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_edg_normalized_method_ROSE_1392> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{118};

  static constexpr char const * const name{"unparse_edg_normalized_method_ROSE_1392"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparse_edg_normalized_method_ROSE_1392};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_edg_normalized_method_ROSE_1392>;

};


template <> struct describe_field_t<SgFile,SgFile::standard_enum,&SgFile::p_standard> {

  using parent = SgFile;

  using field_type = SgFile::standard_enum;

  static constexpr size_t position{119};

  static constexpr char const * const name{"standard"};

  static constexpr char const * const typestr{"SgFile::standard_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_standard};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, SgFile::standard_enum SgFile::*, &SgFile::p_standard>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_gnu_standard> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{120};

  static constexpr char const * const name{"gnu_standard"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_gnu_standard};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_gnu_standard>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_frontendErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{121};

  static constexpr char const * const name{"frontendErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_frontendErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_frontendErrorCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_javacErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{122};

  static constexpr char const * const name{"javacErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_javacErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_javacErrorCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_ecjErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{123};

  static constexpr char const * const name{"ecjErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_ecjErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_ecjErrorCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_midendErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{124};

  static constexpr char const * const name{"midendErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_midendErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_midendErrorCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_unparserErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{125};

  static constexpr char const * const name{"unparserErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparserErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_unparserErrorCode>;

};


template <> struct describe_field_t<SgFile,int,&SgFile::p_backendCompilerErrorCode> {

  using parent = SgFile;

  using field_type = int;

  static constexpr size_t position{126};

  static constexpr char const * const name{"backendCompilerErrorCode"};

  static constexpr char const * const typestr{"int"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_backendCompilerErrorCode};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, int SgFile::*, &SgFile::p_backendCompilerErrorCode>;

};


template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparsedFileFailedCompilation> {

  using parent = SgFile;

  using field_type = bool;

  static constexpr size_t position{127};

  static constexpr char const * const name{"unparsedFileFailedCompilation"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFile::p_unparsedFileFailedCompilation};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparsedFileFailedCompilation>;

};


template <> struct describe_node_t<SgFile> {

  using node = SgFile;

  using base = SgSupport;

  static constexpr char const * const name{"File"};

  static constexpr unsigned long variant{416};

  static constexpr bool concrete{false};

  using subclasses_t = mp::List<SgSourceFile, SgUnknownFile, SgBinaryComposite>;

  using fields_t = mp::List<describe_field_t<SgFile,Sg_File_Info*,&SgFile::p_startOfConstruct>, describe_field_t<SgFile,SgStringList,&SgFile::p_originalCommandLineArgumentList>, describe_field_t<SgFile,int,&SgFile::p_verbose>, describe_field_t<SgFile,bool,&SgFile::p_output_warnings>, describe_field_t<SgFile,bool,&SgFile::p_C_only>, describe_field_t<SgFile,bool,&SgFile::p_Cxx_only>, describe_field_t<SgFile,bool,&SgFile::p_Fortran_only>, describe_field_t<SgFile,bool,&SgFile::p_CoArrayFortran_only>, describe_field_t<SgFile,int,&SgFile::p_upc_threads>, describe_field_t<SgFile,bool,&SgFile::p_Java_only>, describe_field_t<SgFile,bool,&SgFile::p_Jvm_only>, describe_field_t<SgFile,bool,&SgFile::p_Jovial_only>, describe_field_t<SgFile,bool,&SgFile::p_PHP_only>, describe_field_t<SgFile,bool,&SgFile::p_Python_only>, describe_field_t<SgFile,bool,&SgFile::p_Cuda_only>, describe_field_t<SgFile,bool,&SgFile::p_OpenCL_only>, describe_field_t<SgFile,bool,&SgFile::p_Csharp_only>, describe_field_t<SgFile,bool,&SgFile::p_Ada_only>, describe_field_t<SgFile,bool,&SgFile::p_requires_C_preprocessor>, describe_field_t<SgFile,bool,&SgFile::p_binary_only>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_inputFormat>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_outputFormat>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_backendCompileFormat>, describe_field_t<SgFile,bool,&SgFile::p_fortran_implicit_none>, describe_field_t<SgFile,bool,&SgFile::p_openmp>, describe_field_t<SgFile,bool,&SgFile::p_openmp_parse_only>, describe_field_t<SgFile,bool,&SgFile::p_openmp_ast_only>, describe_field_t<SgFile,bool,&SgFile::p_openmp_lowering>, describe_field_t<SgFile,bool,&SgFile::p_openacc>, describe_field_t<SgFile,bool,&SgFile::p_openacc_parse_only>, describe_field_t<SgFile,bool,&SgFile::p_openacc_ast_only>, describe_field_t<SgFile,bool,&SgFile::p_cray_pointer_support>, describe_field_t<SgFile,bool,&SgFile::p_failsafe>, describe_field_t<SgFile,bool,&SgFile::p_output_parser_actions>, describe_field_t<SgFile,bool,&SgFile::p_exit_after_parser>, describe_field_t<SgFile,bool,&SgFile::p_skip_syntax_check>, describe_field_t<SgFile,bool,&SgFile::p_skip_parser>, describe_field_t<SgFile,bool,&SgFile::p_relax_syntax_check>, describe_field_t<SgFile,bool,&SgFile::p_skip_translation_from_edg_ast_to_rose_ast>, describe_field_t<SgFile,bool,&SgFile::p_skip_transformation>, describe_field_t<SgFile,bool,&SgFile::p_skip_unparse>, describe_field_t<SgFile,bool,&SgFile::p_skipfinalCompileStep>, describe_field_t<SgFile,bool,&SgFile::p_unparse_includes>, describe_field_t<SgFile,bool,&SgFile::p_unparse_line_directives>, describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_syntax>, describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_names>, describe_field_t<SgFile,bool,&SgFile::p_unparse_instruction_addresses>, describe_field_t<SgFile,bool,&SgFile::p_unparse_raw_memory_contents>, describe_field_t<SgFile,bool,&SgFile::p_unparse_binary_file_format>, describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_outputLanguage>, describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_inputLanguage>, describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithPath>, describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithoutPath>, describe_field_t<SgFile,std::string,&SgFile::p_unparse_output_filename>, describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithPath>, describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithoutPath>, describe_field_t<SgFile,bool,&SgFile::p_useBackendOnly>, describe_field_t<SgFile,bool,&SgFile::p_compileOnly>, describe_field_t<SgFile,std::string,&SgFile::p_savedFrontendCommandLine>, describe_field_t<SgFile,bool,&SgFile::p_no_implicit_templates>, describe_field_t<SgFile,bool,&SgFile::p_no_implicit_inline_templates>, describe_field_t<SgFile,bool,&SgFile::p_skip_commentsAndDirectives>, describe_field_t<SgFile,bool,&SgFile::p_collectAllCommentsAndDirectives>, describe_field_t<SgFile,bool,&SgFile::p_translateCommentsAndDirectivesIntoAST>, describe_field_t<SgFile,bool,&SgFile::p_unparseHeaderFiles>, describe_field_t<SgFile,ROSEAttributesListContainerPtr,&SgFile::p_preprocessorDirectivesAndCommentsList>, describe_field_t<SgFile,AstAttributeMechanism*,&SgFile::p_attributeMechanism>, describe_field_t<SgFile,bool,&SgFile::p_KCC_frontend>, describe_field_t<SgFile,bool,&SgFile::p_new_frontend>, describe_field_t<SgFile,bool,&SgFile::p_disable_edg_backend>, describe_field_t<SgFile,bool,&SgFile::p_disable_sage_backend>, describe_field_t<SgFile,int,&SgFile::p_testingLevel>, describe_field_t<SgFile,bool,&SgFile::p_preinit_il>, describe_field_t<SgFile,bool,&SgFile::p_enable_cp_backend>, describe_field_t<SgFile,bool,&SgFile::p_markGeneratedFiles>, describe_field_t<SgFile,bool,&SgFile::p_negative_test>, describe_field_t<SgFile,bool,&SgFile::p_strict_language_handling>, describe_field_t<SgFile,bool,&SgFile::p_wave>, describe_field_t<SgFile,int,&SgFile::p_embedColorCodesInGeneratedCode>, describe_field_t<SgFile,int,&SgFile::p_generateSourcePositionCodes>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCppFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortranFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran77FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran90FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran95FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2003FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2008FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCoArrayFortranFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPHPFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPythonFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJavaFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJvmFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesBinaryFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileTypeIsUnknown>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCsharpFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesAdaFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJovialFileExtension>, describe_field_t<SgFile,int,&SgFile::p_detect_dangling_pointers>, describe_field_t<SgFile,bool,&SgFile::p_experimental_flang_frontend>, describe_field_t<SgFile,bool,&SgFile::p_read_executable_file_format_only>, describe_field_t<SgFile,bool,&SgFile::p_visualize_executable_file_format_skip_symbols>, describe_field_t<SgFile,bool,&SgFile::p_visualize_dwarf_only>, describe_field_t<SgFile,bool,&SgFile::p_read_instructions_only>, describe_field_t<SgFile,SgStringList,&SgFile::p_libraryArchiveObjectFileNameList>, describe_field_t<SgFile,bool,&SgFile::p_isLibraryArchive>, describe_field_t<SgFile,bool,&SgFile::p_isObjectFile>, describe_field_t<SgFile,bool,&SgFile::p_unparse_tokens>, describe_field_t<SgFile,int,&SgFile::p_unparse_tokens_testing>, describe_field_t<SgFile,bool,&SgFile::p_unparse_using_leading_and_trailing_token_mappings>, describe_field_t<SgFile,bool,&SgFile::p_unparse_template_ast>, describe_field_t<SgFile,bool,&SgFile::p_skipAstConsistancyTests>, describe_field_t<SgFile,bool,&SgFile::p_multifile_support>, describe_field_t<SgFile,bool,&SgFile::p_optimization>, describe_field_t<SgFile,bool,&SgFile::p_use_token_stream_to_improve_source_position_info>, describe_field_t<SgFile,bool,&SgFile::p_suppress_variable_declaration_normalization>, describe_field_t<SgFile,bool,&SgFile::p_edg_il_to_graphviz>, describe_field_t<SgFile,bool,&SgFile::p_clang_il_to_graphviz>, describe_field_t<SgFile,bool,&SgFile::p_no_optimize_flag_for_frontend>, describe_field_t<SgFile,bool,&SgFile::p_unparse_edg_normalized_method_ROSE_1392>, describe_field_t<SgFile,SgFile::standard_enum,&SgFile::p_standard>, describe_field_t<SgFile,bool,&SgFile::p_gnu_standard>, describe_field_t<SgFile,int,&SgFile::p_frontendErrorCode>, describe_field_t<SgFile,int,&SgFile::p_javacErrorCode>, describe_field_t<SgFile,int,&SgFile::p_ecjErrorCode>, describe_field_t<SgFile,int,&SgFile::p_midendErrorCode>, describe_field_t<SgFile,int,&SgFile::p_unparserErrorCode>, describe_field_t<SgFile,int,&SgFile::p_backendCompilerErrorCode>, describe_field_t<SgFile,bool,&SgFile::p_unparsedFileFailedCompilation>>;

};


template <> struct node_from_variant_t<416> { using type = SgFile; };


// Class: FileList


template <> struct describe_field_t<SgFileList,SgFilePtrList,&SgFileList::p_listOfFiles> {

  using parent = SgFileList;

  using field_type = SgFilePtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"listOfFiles"};

  static constexpr char const * const typestr{"SgFilePtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgFileList::p_listOfFiles};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFileList, SgFilePtrList SgFileList::*, &SgFileList::p_listOfFiles>;

};


template <> struct describe_field_t<SgFileList,AstAttributeMechanism*,&SgFileList::p_attributeMechanism> {

  using parent = SgFileList;

  using field_type = AstAttributeMechanism*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"attributeMechanism"};

  static constexpr char const * const typestr{"AstAttributeMechanism*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFileList::p_attributeMechanism};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFileList, AstAttributeMechanism* SgFileList::*, &SgFileList::p_attributeMechanism>;

};


template <> struct describe_node_t<SgFileList> {

  using node = SgFileList;

  using base = SgSupport;

  static constexpr char const * const name{"FileList"};

  static constexpr unsigned long variant{417};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgFileList,SgFilePtrList,&SgFileList::p_listOfFiles>, describe_field_t<SgFileList,AstAttributeMechanism*,&SgFileList::p_attributeMechanism>>;

};


template <> struct node_from_variant_t<417> { using type = SgFileList; };


// Class: FloatVal


template <> struct describe_field_t<SgFloatVal,float,&SgFloatVal::p_value> {

  using parent = SgFloatVal;

  using field_type = float;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"float"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFloatVal::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloatVal, float SgFloatVal::*, &SgFloatVal::p_value>;

};


template <> struct describe_field_t<SgFloatVal,std::string,&SgFloatVal::p_valueString> {

  using parent = SgFloatVal;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgFloatVal::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloatVal, std::string SgFloatVal::*, &SgFloatVal::p_valueString>;

};


template <> struct describe_node_t<SgFloatVal> {

  using node = SgFloatVal;

  using base = SgValueExp;

  static constexpr char const * const name{"FloatVal"};

  static constexpr unsigned long variant{418};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgFloatVal,float,&SgFloatVal::p_value>, describe_field_t<SgFloatVal,std::string,&SgFloatVal::p_valueString>>;

};


template <> struct node_from_variant_t<418> { using type = SgFloatVal; };


// Class: Float128Val


template <> struct describe_field_t<SgFloat128Val,long double,&SgFloat128Val::p_value> {

  using parent = SgFloat128Val;

  using field_type = long double;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"long double"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFloat128Val::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloat128Val, long double SgFloat128Val::*, &SgFloat128Val::p_value>;

};


template <> struct describe_field_t<SgFloat128Val,std::string,&SgFloat128Val::p_valueString> {

  using parent = SgFloat128Val;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgFloat128Val::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloat128Val, std::string SgFloat128Val::*, &SgFloat128Val::p_valueString>;

};


template <> struct describe_node_t<SgFloat128Val> {

  using node = SgFloat128Val;

  using base = SgValueExp;

  static constexpr char const * const name{"Float128Val"};

  static constexpr unsigned long variant{419};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgFloat128Val,long double,&SgFloat128Val::p_value>, describe_field_t<SgFloat128Val,std::string,&SgFloat128Val::p_valueString>>;

};


template <> struct node_from_variant_t<419> { using type = SgFloat128Val; };


// Class: Float80Val


template <> struct describe_field_t<SgFloat80Val,long double,&SgFloat80Val::p_value> {

  using parent = SgFloat80Val;

  using field_type = long double;

  static constexpr size_t position{0};

  static constexpr char const * const name{"value"};

  static constexpr char const * const typestr{"long double"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFloat80Val::p_value};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloat80Val, long double SgFloat80Val::*, &SgFloat80Val::p_value>;

};


template <> struct describe_field_t<SgFloat80Val,std::string,&SgFloat80Val::p_valueString> {

  using parent = SgFloat80Val;

  using field_type = std::string;

  static constexpr size_t position{1};

  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{&SgFloat80Val::p_valueString};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFloat80Val, std::string SgFloat80Val::*, &SgFloat80Val::p_valueString>;

};


template <> struct describe_node_t<SgFloat80Val> {

  using node = SgFloat80Val;

  using base = SgValueExp;

  static constexpr char const * const name{"Float80Val"};

  static constexpr unsigned long variant{420};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgFloat80Val,long double,&SgFloat80Val::p_value>, describe_field_t<SgFloat80Val,std::string,&SgFloat80Val::p_valueString>>;

};


template <> struct node_from_variant_t<420> { using type = SgFloat80Val; };


// Class: FoldExpression


template <> struct describe_field_t<SgFoldExpression,SgExpression*,&SgFoldExpression::p_operands> {

  using parent = SgFoldExpression;

  using field_type = SgExpression*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"operands"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgFoldExpression::p_operands};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFoldExpression, SgExpression* SgFoldExpression::*, &SgFoldExpression::p_operands>;

};


template <> struct describe_field_t<SgFoldExpression,std::string,&SgFoldExpression::p_operator_token> {

  using parent = SgFoldExpression;

  using field_type = std::string;

  static constexpr size_t position{1};

  static constexpr char const * const name{"operator_token"};

  static constexpr char const * const typestr{"std::string"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFoldExpression::p_operator_token};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFoldExpression, std::string SgFoldExpression::*, &SgFoldExpression::p_operator_token>;

};


template <> struct describe_field_t<SgFoldExpression,bool,&SgFoldExpression::p_is_left_associative> {

  using parent = SgFoldExpression;

  using field_type = bool;

  static constexpr size_t position{2};

  static constexpr char const * const name{"is_left_associative"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgFoldExpression::p_is_left_associative};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgFoldExpression, bool SgFoldExpression::*, &SgFoldExpression::p_is_left_associative>;

};


template <> struct describe_node_t<SgFoldExpression> {

  using node = SgFoldExpression;

  using base = SgExpression;

  static constexpr char const * const name{"FoldExpression"};

  static constexpr unsigned long variant{421};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgFoldExpression,SgExpression*,&SgFoldExpression::p_operands>, describe_field_t<SgFoldExpression,std::string,&SgFoldExpression::p_operator_token>, describe_field_t<SgFoldExpression,bool,&SgFoldExpression::p_is_left_associative>>;

};


template <> struct node_from_variant_t<421> { using type = SgFoldExpression; };


// Class: FlushStatement


template <> struct describe_node_t<SgFlushStatement> {

  using node = SgFlushStatement;

  using base = SgIOStatement;

  static constexpr char const * const name{"FlushStatement"};

  static constexpr unsigned long variant{422};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<>;

};


template <> struct node_from_variant_t<422> { using type = SgFlushStatement; };


// Class: ForAllStatement


template <> struct describe_field_t<SgForAllStatement,SgExprListExp*,&SgForAllStatement::p_forall_header> {

  using parent = SgForAllStatement;

  using field_type = SgExprListExp*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"forall_header"};

  static constexpr char const * const typestr{"SgExprListExp*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForAllStatement::p_forall_header};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, SgExprListExp* SgForAllStatement::*, &SgForAllStatement::p_forall_header>;

};


template <> struct describe_field_t<SgForAllStatement,SgBasicBlock*,&SgForAllStatement::p_body> {

  using parent = SgForAllStatement;

  using field_type = SgBasicBlock*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"body"};

  static constexpr char const * const typestr{"SgBasicBlock*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForAllStatement::p_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, SgBasicBlock* SgForAllStatement::*, &SgForAllStatement::p_body>;

};


template <> struct describe_field_t<SgForAllStatement,bool,&SgForAllStatement::p_has_end_statement> {

  using parent = SgForAllStatement;

  using field_type = bool;

  static constexpr size_t position{2};

  static constexpr char const * const name{"has_end_statement"};

  static constexpr char const * const typestr{"bool"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgForAllStatement::p_has_end_statement};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, bool SgForAllStatement::*, &SgForAllStatement::p_has_end_statement>;

};


template <> struct describe_field_t<SgForAllStatement,std::string,&SgForAllStatement::p_string_label> {

  using parent = SgForAllStatement;

  using field_type = std::string;

  static constexpr size_t position{3};

  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{&SgForAllStatement::p_string_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, std::string SgForAllStatement::*, &SgForAllStatement::p_string_label>;

};


template <> struct describe_field_t<SgForAllStatement,SgLabelRefExp*,&SgForAllStatement::p_end_numeric_label> {

  using parent = SgForAllStatement;

  using field_type = SgLabelRefExp*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"end_numeric_label"};

  static constexpr char const * const typestr{"SgLabelRefExp*"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgForAllStatement::p_end_numeric_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, SgLabelRefExp* SgForAllStatement::*, &SgForAllStatement::p_end_numeric_label>;

};


template <> struct describe_field_t<SgForAllStatement,SgForAllStatement::forall_statement_kind_enum,&SgForAllStatement::p_forall_statement_kind> {

  using parent = SgForAllStatement;

  using field_type = SgForAllStatement::forall_statement_kind_enum;

  static constexpr size_t position{5};

  static constexpr char const * const name{"forall_statement_kind"};

  static constexpr char const * const typestr{"SgForAllStatement::forall_statement_kind_enum"};

  static constexpr bool traverse{false};

  static constexpr auto mbr_ptr{&SgForAllStatement::p_forall_statement_kind};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForAllStatement, SgForAllStatement::forall_statement_kind_enum SgForAllStatement::*, &SgForAllStatement::p_forall_statement_kind>;

};


template <> struct describe_node_t<SgForAllStatement> {

  using node = SgForAllStatement;

  using base = SgScopeStatement;

  static constexpr char const * const name{"ForAllStatement"};

  static constexpr unsigned long variant{423};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgForAllStatement,SgExprListExp*,&SgForAllStatement::p_forall_header>, describe_field_t<SgForAllStatement,SgBasicBlock*,&SgForAllStatement::p_body>, describe_field_t<SgForAllStatement,bool,&SgForAllStatement::p_has_end_statement>, describe_field_t<SgForAllStatement,std::string,&SgForAllStatement::p_string_label>, describe_field_t<SgForAllStatement,SgLabelRefExp*,&SgForAllStatement::p_end_numeric_label>, describe_field_t<SgForAllStatement,SgForAllStatement::forall_statement_kind_enum,&SgForAllStatement::p_forall_statement_kind>>;

};


template <> struct node_from_variant_t<423> { using type = SgForAllStatement; };


// Class: ForInitStatement


template <> struct describe_field_t<SgForInitStatement,SgStatementPtrList,&SgForInitStatement::p_init_stmt> {

  using parent = SgForInitStatement;

  using field_type = SgStatementPtrList;

  static constexpr size_t position{0};

  static constexpr char const * const name{"init_stmt"};

  static constexpr char const * const typestr{"SgStatementPtrList"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForInitStatement::p_init_stmt};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForInitStatement, SgStatementPtrList SgForInitStatement::*, &SgForInitStatement::p_init_stmt>;

};


template <> struct describe_node_t<SgForInitStatement> {

  using node = SgForInitStatement;

  using base = SgStatement;

  static constexpr char const * const name{"ForInitStatement"};

  static constexpr unsigned long variant{424};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgForInitStatement,SgStatementPtrList,&SgForInitStatement::p_init_stmt>>;

};


template <> struct node_from_variant_t<424> { using type = SgForInitStatement; };


// Class: ForStatement


template <> struct describe_field_t<SgForStatement,SgForInitStatement*,&SgForStatement::p_for_init_stmt> {

  using parent = SgForStatement;

  using field_type = SgForInitStatement*;

  static constexpr size_t position{0};

  static constexpr char const * const name{"for_init_stmt"};

  static constexpr char const * const typestr{"SgForInitStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForStatement::p_for_init_stmt};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, SgForInitStatement* SgForStatement::*, &SgForStatement::p_for_init_stmt>;

};


template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_test> {

  using parent = SgForStatement;

  using field_type = SgStatement*;

  static constexpr size_t position{1};

  static constexpr char const * const name{"test"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForStatement::p_test};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_test>;

};


template <> struct describe_field_t<SgForStatement,SgExpression*,&SgForStatement::p_increment> {

  using parent = SgForStatement;

  using field_type = SgExpression*;

  static constexpr size_t position{2};

  static constexpr char const * const name{"increment"};

  static constexpr char const * const typestr{"SgExpression*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForStatement::p_increment};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, SgExpression* SgForStatement::*, &SgForStatement::p_increment>;

};


template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_loop_body> {

  using parent = SgForStatement;

  using field_type = SgStatement*;

  static constexpr size_t position{3};

  static constexpr char const * const name{"loop_body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForStatement::p_loop_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_loop_body>;

};


template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_else_body> {

  using parent = SgForStatement;

  using field_type = SgStatement*;

  static constexpr size_t position{4};

  static constexpr char const * const name{"else_body"};

  static constexpr char const * const typestr{"SgStatement*"};

  static constexpr bool traverse{true};

  static constexpr auto mbr_ptr{&SgForStatement::p_else_body};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_else_body>;

};


template <> struct describe_field_t<SgForStatement,std::string,&SgForStatement::p_string_label> {

  using parent = SgForStatement;

  using field_type = std::string;

  static constexpr size_t position{5};

  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{&SgForStatement::p_string_label};

  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>

  using bind = Desc<SgForStatement, std::string SgForStatement::*, &SgForStatement::p_string_label>;

};


template <> struct describe_node_t<SgForStatement> {

  using node = SgForStatement;

  using base = SgScopeStatement;

  static constexpr char const * const name{"ForStatement"};

  static constexpr unsigned long variant{425};

  static constexpr bool concrete{true};

  using subclasses_t = mp::List<>;

  using fields_t = mp::List<describe_field_t<SgForStatement,SgForInitStatement*,&SgForStatement::p_for_init_stmt>, describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_test>, describe_field_t<SgForStatement,SgExpression*,&SgForStatement::p_increment>, describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_loop_body>, describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_else_body>, describe_field_t<SgForStatement,std::string,&SgForStatement::p_string_label>>;

};


template <> struct node_from_variant_t<425> { using type = SgForStatement; };


// Class: FormatItem