stringify.h

// DO NOT EDIT -- This file is automatically generated.
 
#ifndef ROSE_STRINGIFY_H
#define ROSE_STRINGIFY_H
#include <boost/algorithm/string/predicate.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>
 
namespace Rose {
class Stringifier {
    std::string(*stringifier_)(int64_t, const char*, bool);
public:
    Stringifier(std::string(*stringifier)(int64_t, const char*, bool)): stringifier_(stringifier) {}
    std::string operator()(int64_t n, const char *strip=NULL, bool canonic=false) {
        return stringifier_(n, strip, canonic);
    }
};
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/utility_functions.C line 840
namespace stringify {
    const char* language_enum(int64_t);
 
    std::string language_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& language_enum();
}
 
namespace Rose {
    std::string stringify_language_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_language_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/transformationSupport.h line 37
namespace stringify { namespace TransformationSupport {
    const char* operatorCodeType(int64_t);
 
    std::string operatorCodeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& operatorCodeType();
}}
 
namespace Rose {
    std::string stringifyTransformationSupport_operatorCodeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTransformationSupport_operatorCodeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/CommandLine.C line 17
namespace stringify { namespace Rose { namespace CommandLine { namespace FailedAssertionBehaviorAdjuster {
    const char* Behavior(int64_t);
 
    std::string Behavior(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Behavior();
}}}}
 
namespace Rose {
    std::string stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 266
namespace stringify {
    const char* an_init_kind_tag(int64_t);
 
    std::string an_init_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_init_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_init_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 1182
namespace stringify {
    const char* a_decl_modifier_tag(int64_t);
 
    std::string a_decl_modifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_decl_modifier_tag();
}
 
namespace Rose {
    std::string stringify_a_decl_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_decl_modifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 7715
namespace stringify {
    const char* a_local_expr_node_ref_kind_tag(int64_t);
 
    std::string a_local_expr_node_ref_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_local_expr_node_ref_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_local_expr_node_ref_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_local_expr_node_ref_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 10917
namespace stringify {
    const char* an_operand_kind_tag(int64_t);
 
    std::string an_operand_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_operand_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_operand_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_operand_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 12859
namespace stringify {
    const char* a_pragma_kind_tag(int64_t);
 
    std::string a_pragma_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_pragma_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pragma_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 13914
namespace stringify {
    const char* a_name_linkage_kind_tag(int64_t);
 
    std::string a_name_linkage_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_name_linkage_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_name_linkage_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_name_linkage_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 6393
namespace stringify {
    const char* kinds_of_type_references(int64_t);
 
    std::string kinds_of_type_references(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& kinds_of_type_references();
}
 
namespace Rose {
    std::string stringify_kinds_of_type_references(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_kinds_of_type_references();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 46817
namespace stringify {
    const char* a_special_function_kind_tag(int64_t);
 
    std::string a_special_function_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_special_function_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_special_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_special_function_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/lib_src/eh.h line 348
namespace stringify {
    const char* an_eh_stack_entry_kind_tag(int64_t);
 
    std::string an_eh_stack_entry_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_eh_stack_entry_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_eh_stack_entry_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_eh_stack_entry_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/pragma.h line 52
namespace stringify {
    const char* a_pragma_binding_kind(int64_t);
 
    std::string a_pragma_binding_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_pragma_binding_kind();
}
 
namespace Rose {
    std::string stringify_a_pragma_binding_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pragma_binding_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/lower_il.h line 424
namespace stringify {
    const char* an_insert_location_kind(int64_t);
 
    std::string an_insert_location_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_insert_location_kind();
}
 
namespace Rose {
    std::string stringify_an_insert_location_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_insert_location_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 1032
namespace stringify { namespace a_type_wrapper {
    const char* a_kind(int64_t);
 
    std::string a_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_kind();
}}
 
namespace Rose {
    std::string stringify_a_type_wrapper_a_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_wrapper_a_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 1293
namespace stringify { namespace a_class_type_wrapper {
    const char* a_class_kind(int64_t);
 
    std::string a_class_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_class_kind();
}}
 
namespace Rose {
    std::string stringify_a_class_type_wrapper_a_class_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_class_type_wrapper_a_class_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 1414
namespace stringify { namespace a_type_indirection {
    const char* an_indirection_kind(int64_t);
 
    std::string an_indirection_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_indirection_kind();
}}
 
namespace Rose {
    std::string stringify_a_type_indirection_an_indirection_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_indirection_an_indirection_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 1566
namespace stringify { namespace an_array_type_wrapper {
    const char* an_array_kind(int64_t);
 
    std::string an_array_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_array_kind();
}}
 
namespace Rose {
    std::string stringify_an_array_type_wrapper_an_array_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_array_type_wrapper_an_array_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 3807
namespace stringify { namespace an_accessibility {
    const char* access_kind(int64_t);
 
    std::string access_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_kind();
}}
 
namespace Rose {
    std::string stringify_an_accessibility_access_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_accessibility_access_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.cpp line 3846
namespace stringify { namespace a_type_definition {
    const char* a_type_definition_kind(int64_t);
 
    std::string a_type_definition_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_definition_kind();
}}
 
namespace Rose {
    std::string stringify_a_type_definition_a_type_definition_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_definition_a_type_definition_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.h line 22
namespace stringify {
    const char* a_cpp_cli_import_flag_tag(int64_t);
 
    std::string a_cpp_cli_import_flag_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cpp_cli_import_flag_tag();
}
 
namespace Rose {
    std::string stringify_a_cpp_cli_import_flag_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cpp_cli_import_flag_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/expr.h line 93
namespace stringify {
    const char* an_init_component_kind_tag(int64_t);
 
    std::string an_init_component_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_init_component_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_init_component_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_init_component_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/interpret.h line 59
namespace stringify {
    const char* a_constexpr_intrinsic_tag(int64_t);
 
    std::string a_constexpr_intrinsic_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_constexpr_intrinsic_tag();
}
 
namespace Rose {
    std::string stringify_a_constexpr_intrinsic_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_constexpr_intrinsic_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/statements.h line 56
namespace stringify {
    const char* a_control_flow_descr_kind_tag(int64_t);
 
    std::string a_control_flow_descr_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_control_flow_descr_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_control_flow_descr_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_control_flow_descr_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 106
namespace stringify {
    const char* an_expression_kind_tag(int64_t);
 
    std::string an_expression_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_expression_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_expression_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expression_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 143
namespace stringify {
    const char* a_cast_source_form(int64_t);
 
    std::string a_cast_source_form(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cast_source_form();
}
 
namespace Rose {
    std::string stringify_a_cast_source_form(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cast_source_form();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 162
namespace stringify {
    const char* an_overload_context(int64_t);
 
    std::string an_overload_context(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_overload_context();
}
 
namespace Rose {
    std::string stringify_an_overload_context(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_overload_context();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 195
namespace stringify {
    const char* a_type_class_kind(int64_t);
 
    std::string a_type_class_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_class_kind();
}
 
namespace Rose {
    std::string stringify_a_type_class_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_class_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 323
namespace stringify {
    const char* an_operand_state_tag(int64_t);
 
    std::string an_operand_state_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_operand_state_tag();
}
 
namespace Rose {
    std::string stringify_an_operand_state_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_operand_state_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/host_envir.h line 2382
namespace stringify {
    const char* a_unicode_source_kind_tag(int64_t);
 
    std::string a_unicode_source_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_unicode_source_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_unicode_source_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_unicode_source_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/host_envir.h line 3758
namespace stringify {
    const char* a_predef_macro_mode(int64_t);
 
    std::string a_predef_macro_mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_predef_macro_mode();
}
 
namespace Rose {
    std::string stringify_a_predef_macro_mode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_predef_macro_mode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/floating.h line 416
namespace stringify {
    const char* an_fp_type(int64_t);
 
    std::string an_fp_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_fp_type();
}
 
namespace Rose {
    std::string stringify_an_fp_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_fp_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/floating.h line 515
namespace stringify {
    const char* an_fp_return_type(int64_t);
 
    std::string an_fp_return_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_fp_return_type();
}
 
namespace Rose {
    std::string stringify_an_fp_return_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_fp_return_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/lexical.h line 1973
namespace stringify {
    const char* a_token_extra_info_kind_tag(int64_t);
 
    std::string a_token_extra_info_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_token_extra_info_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_token_extra_info_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_token_extra_info_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/mem_manage.h line 421
namespace stringify {
    const char* a_function_number_tag(int64_t);
 
    std::string a_function_number_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_function_number_tag();
}
 
namespace Rose {
    std::string stringify_a_function_number_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_function_number_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/sys_predef.h line 220
namespace stringify {
    const char* a_builtin_user_function_kind_tag(int64_t);
 
    std::string a_builtin_user_function_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_user_function_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_builtin_user_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_user_function_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/sys_predef.h line 453
namespace stringify {
    const char* a_multiversion_arch_kind_tag(int64_t);
 
    std::string a_multiversion_arch_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_multiversion_arch_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_multiversion_arch_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_multiversion_arch_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 387
namespace stringify {
    const char* an_access_specifier_tag(int64_t);
 
    std::string an_access_specifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_access_specifier_tag();
}
 
namespace Rose {
    std::string stringify_an_access_specifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_access_specifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 407
namespace stringify {
    const char* an_assembly_visibility_tag(int64_t);
 
    std::string an_assembly_visibility_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_assembly_visibility_tag();
}
 
namespace Rose {
    std::string stringify_an_assembly_visibility_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_assembly_visibility_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 1570
namespace stringify {
    const char* an_element_position_kind_tag(int64_t);
 
    std::string an_element_position_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_element_position_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_element_position_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_element_position_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 1680
namespace stringify {
    const char* an_ELF_visibility_kind_tag(int64_t);
 
    std::string an_ELF_visibility_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_ELF_visibility_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_ELF_visibility_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ELF_visibility_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2398
namespace stringify {
    const char* an_attribute_arg_kind_tag(int64_t);
 
    std::string an_attribute_arg_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_attribute_arg_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_attribute_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_arg_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2474
namespace stringify {
    const char* an_attribute_family_tag(int64_t);
 
    std::string an_attribute_family_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_attribute_family_tag();
}
 
namespace Rose {
    std::string stringify_an_attribute_family_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_family_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2499
namespace stringify {
    const char* an_attribute_location_tag(int64_t);
 
    std::string an_attribute_location_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_attribute_location_tag();
}
 
namespace Rose {
    std::string stringify_an_attribute_location_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_location_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2568
namespace stringify {
    const char* an_attribute_kind_tag(int64_t);
 
    std::string an_attribute_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_attribute_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_attribute_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3206
namespace stringify {
    const char* a_constant_repr_kind_tag(int64_t);
 
    std::string a_constant_repr_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_constant_repr_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_constant_repr_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_constant_repr_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3258
namespace stringify {
    const char* an_address_base_kind_tag(int64_t);
 
    std::string an_address_base_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_address_base_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_address_base_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_address_base_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3519
namespace stringify {
    const char* a_dynamic_init_kind_tag(int64_t);
 
    std::string a_dynamic_init_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_dynamic_init_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_dynamic_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_dynamic_init_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3953
namespace stringify {
    const char* a_template_param_constant_kind_tag(int64_t);
 
    std::string a_template_param_constant_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_template_param_constant_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_template_param_constant_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_param_constant_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4087
namespace stringify {
    const char* a_character_kind_tag(int64_t);
 
    std::string a_character_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_character_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_character_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_character_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4909
namespace stringify {
    const char* a_type_kind_tag(int64_t);
 
    std::string a_type_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4957
namespace stringify {
    const char* an_integer_kind_tag(int64_t);
 
    std::string an_integer_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_integer_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_integer_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_integer_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5047
namespace stringify {
    const char* a_fixed_point_precision_tag(int64_t);
 
    std::string a_fixed_point_precision_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_fixed_point_precision_tag();
}
 
namespace Rose {
    std::string stringify_a_fixed_point_precision_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_fixed_point_precision_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5079
namespace stringify {
    const char* a_float_kind_tag(int64_t);
 
    std::string a_float_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_float_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_float_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_float_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5105
namespace stringify {
    const char* a_type_mode_kind_tag(int64_t);
 
    std::string a_type_mode_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_mode_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_type_mode_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_mode_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5161
namespace stringify {
    const char* an_asm_operand_constraint_kind_tag(int64_t);
 
    std::string an_asm_operand_constraint_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_asm_operand_constraint_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_asm_operand_constraint_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_asm_operand_constraint_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5326
namespace stringify {
    const char* an_asm_operand_modifier_tag(int64_t);
 
    std::string an_asm_operand_modifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_asm_operand_modifier_tag();
}
 
namespace Rose {
    std::string stringify_an_asm_operand_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_asm_operand_modifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5337
namespace stringify {
    const char* a_named_register_tag(int64_t);
 
    std::string a_named_register_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_named_register_tag();
}
 
namespace Rose {
    std::string stringify_a_named_register_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_named_register_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5512
namespace stringify {
    const char* a_type_qualifier_tag(int64_t);
 
    std::string a_type_qualifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_qualifier_tag();
}
 
namespace Rose {
    std::string stringify_a_type_qualifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_qualifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5614
namespace stringify {
    const char* a_upc_pragma_kind_tag(int64_t);
 
    std::string a_upc_pragma_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_upc_pragma_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_upc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_pragma_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5624
namespace stringify {
    const char* a_upc_access_method_tag(int64_t);
 
    std::string a_upc_access_method_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_upc_access_method_tag();
}
 
namespace Rose {
    std::string stringify_a_upc_access_method_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_access_method_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5635
namespace stringify {
    const char* a_upc_coherence_stack_operation_tag(int64_t);
 
    std::string a_upc_coherence_stack_operation_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_upc_coherence_stack_operation_tag();
}
 
namespace Rose {
    std::string stringify_a_upc_coherence_stack_operation_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_coherence_stack_operation_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5816
namespace stringify {
    const char* a_stdc_pragma_kind_tag(int64_t);
 
    std::string a_stdc_pragma_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_stdc_pragma_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_stdc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_stdc_pragma_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5842
namespace stringify {
    const char* a_stdc_pragma_value_tag(int64_t);
 
    std::string a_stdc_pragma_value_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_stdc_pragma_value_tag();
}
 
namespace Rose {
    std::string stringify_a_stdc_pragma_value_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_stdc_pragma_value_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5863
namespace stringify {
    const char* a_gcc_pragma_kind_tag(int64_t);
 
    std::string a_gcc_pragma_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_gcc_pragma_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_gcc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_gcc_pragma_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6133
namespace stringify {
    const char* a_microsoft_pragma_comment_type_tag(int64_t);
 
    std::string a_microsoft_pragma_comment_type_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_microsoft_pragma_comment_type_tag();
}
 
namespace Rose {
    std::string stringify_a_microsoft_pragma_comment_type_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_microsoft_pragma_comment_type_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6147
namespace stringify {
    const char* a_microsoft_pragma_conform_kind_tag(int64_t);
 
    std::string a_microsoft_pragma_conform_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_microsoft_pragma_conform_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_microsoft_pragma_conform_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_microsoft_pragma_conform_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6454
namespace stringify {
    const char* a_calling_convention_tag(int64_t);
 
    std::string a_calling_convention_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_calling_convention_tag();
}
 
namespace Rose {
    std::string stringify_a_calling_convention_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_calling_convention_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6642
namespace stringify {
    const char* a_ref_qualifier_kind_tag(int64_t);
 
    std::string a_ref_qualifier_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_ref_qualifier_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_ref_qualifier_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_ref_qualifier_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6924
namespace stringify {
    const char* a_templ_arg_kind_tag(int64_t);
 
    std::string a_templ_arg_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_templ_arg_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_templ_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_templ_arg_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7554
namespace stringify {
    const char* an_anonymous_union_kind_tag(int64_t);
 
    std::string an_anonymous_union_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_anonymous_union_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_anonymous_union_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_anonymous_union_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7569
namespace stringify {
    const char* an_inheritance_kind_tag(int64_t);
 
    std::string an_inheritance_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_inheritance_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_inheritance_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_inheritance_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7603
namespace stringify {
    const char* a_cli_class_type_kind_tag(int64_t);
 
    std::string a_cli_class_type_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cli_class_type_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_cli_class_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_class_type_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7636
namespace stringify {
    const char* a_property_or_event_kind_tag(int64_t);
 
    std::string a_property_or_event_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_property_or_event_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_property_or_event_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_property_or_event_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7769
namespace stringify {
    const char* a_rewritten_property_reference_kind_tag(int64_t);
 
    std::string a_rewritten_property_reference_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_rewritten_property_reference_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_rewritten_property_reference_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_rewritten_property_reference_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8436
namespace stringify {
    const char* a_template_param_type_kind_tag(int64_t);
 
    std::string a_template_param_type_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_template_param_type_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_template_param_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_param_type_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8702
namespace stringify {
    const char* a_based_type_kind_tag(int64_t);
 
    std::string a_based_type_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_based_type_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_based_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_based_type_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8763
namespace stringify {
    const char* a_pointer_modifier_tag(int64_t);
 
    std::string a_pointer_modifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_pointer_modifier_tag();
}
 
namespace Rose {
    std::string stringify_a_pointer_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pointer_modifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 9944
namespace stringify {
    const char* a_storage_class_tag(int64_t);
 
    std::string a_storage_class_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_storage_class_tag();
}
 
namespace Rose {
    std::string stringify_a_storage_class_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_storage_class_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 11066
namespace stringify {
    const char* an_opname_kind_tag(int64_t);
 
    std::string an_opname_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_opname_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_opname_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_opname_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 11121
namespace stringify {
    const char* a_ctor_or_dtor_kind_tag(int64_t);
 
    std::string a_ctor_or_dtor_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_ctor_or_dtor_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_ctor_or_dtor_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_ctor_or_dtor_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12399
namespace stringify {
    const char* an_expr_node_kind_tag(int64_t);
 
    std::string an_expr_node_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_expr_node_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_expr_node_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expr_node_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12524
namespace stringify {
    const char* a_lowered_eh_construct_kind_tag(int64_t);
 
    std::string a_lowered_eh_construct_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_lowered_eh_construct_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_lowered_eh_construct_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_lowered_eh_construct_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12566
namespace stringify {
    const char* an_expr_operator_kind_tag(int64_t);
 
    std::string an_expr_operator_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_expr_operator_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_expr_operator_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expr_operator_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 13090
namespace stringify {
    const char* a_builtin_operation_kind_tag(int64_t);
 
    std::string a_builtin_operation_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_operation_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_builtin_operation_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_operation_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 14313
namespace stringify {
    const char* a_statement_kind_tag(int64_t);
 
    std::string a_statement_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_statement_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_statement_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_statement_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 14542
namespace stringify {
    const char* a_for_each_pattern_kind_tag(int64_t);
 
    std::string a_for_each_pattern_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_for_each_pattern_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_for_each_pattern_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_for_each_pattern_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15361
namespace stringify {
    const char* a_constructor_init_kind_tag(int64_t);
 
    std::string a_constructor_init_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_constructor_init_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_constructor_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_constructor_init_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15587
namespace stringify {
    const char* a_generic_constraint_kind_tag(int64_t);
 
    std::string a_generic_constraint_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_generic_constraint_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_generic_constraint_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_generic_constraint_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15675
namespace stringify {
    const char* a_template_parameter_kind_tag(int64_t);
 
    std::string a_template_parameter_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_template_parameter_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_template_parameter_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_parameter_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15779
namespace stringify {
    const char* a_template_kind_tag(int64_t);
 
    std::string a_template_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_template_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_template_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16125
namespace stringify {
    const char* an_object_lifetime_kind_tag(int64_t);
 
    std::string an_object_lifetime_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_object_lifetime_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_object_lifetime_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_object_lifetime_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16268
namespace stringify {
    const char* an_ms_attribute_kind_tag(int64_t);
 
    std::string an_ms_attribute_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_ms_attribute_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_ms_attribute_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ms_attribute_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16290
namespace stringify {
    const char* an_ms_attribute_arg_kind_tag(int64_t);
 
    std::string an_ms_attribute_arg_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_ms_attribute_arg_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_ms_attribute_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ms_attribute_arg_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16680
namespace stringify {
    const char* a_scope_kind_tag(int64_t);
 
    std::string a_scope_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_scope_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_scope_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_scope_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 25
namespace stringify {
    const char* a_builtin_function_type_index(int64_t);
 
    std::string a_builtin_function_type_index(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_function_type_index();
}
 
namespace Rose {
    std::string stringify_a_builtin_function_type_index(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_type_index();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 5812
namespace stringify {
    const char* a_builtin_function_condition_index(int64_t);
 
    std::string a_builtin_function_condition_index(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_function_condition_index();
}
 
namespace Rose {
    std::string stringify_a_builtin_function_condition_index(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_condition_index();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 6527
namespace stringify {
    const char* a_builtin_function_kind_tag(int64_t);
 
    std::string a_builtin_function_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_function_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_builtin_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il.h line 83
namespace stringify {
    const char* a_type_info_kind_tag(int64_t);
 
    std::string a_type_info_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_info_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_type_info_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_info_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/symbol_tbl.h line 464
namespace stringify {
    const char* a_symbol_kind_tag(int64_t);
 
    std::string a_symbol_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_symbol_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_symbol_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_symbol_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/symbol_tbl.h line 763
namespace stringify {
    const char* a_dependent_type_fixup_kind_tag(int64_t);
 
    std::string a_dependent_type_fixup_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_dependent_type_fixup_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_dependent_type_fixup_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_dependent_type_fixup_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/symbol_tbl.h line 4006
namespace stringify {
    const char* a_cli_operator_kind_tag(int64_t);
 
    std::string a_cli_operator_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cli_operator_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_cli_operator_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_operator_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/symbol_tbl.h line 4901
namespace stringify {
    const char* a_cli_symbol_kind_tag(int64_t);
 
    std::string a_cli_symbol_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cli_symbol_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_cli_symbol_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_symbol_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 62
namespace stringify { namespace __cxxabiv1 { namespace __base_class_type_info {
    const char* __offset_flags_masks(int64_t);
 
    std::string __offset_flags_masks(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& __offset_flags_masks();
}}}
 
namespace Rose {
    std::string stringify__cxxabiv1__base_class_type_info__offset_flags_masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__base_class_type_info__offset_flags_masks();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 77
namespace stringify { namespace __cxxabiv1 { namespace __vmi_class_type_info {
    const char* __flags_masks(int64_t);
 
    std::string __flags_masks(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& __flags_masks();
}}}
 
namespace Rose {
    std::string stringify__cxxabiv1__vmi_class_type_info__flags_masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__vmi_class_type_info__flags_masks();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 90
namespace stringify { namespace __cxxabiv1 { namespace __pbase_type_info {
    const char* __masks(int64_t);
 
    std::string __masks(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& __masks();
}}}
 
namespace Rose {
    std::string stringify__cxxabiv1__pbase_type_info__masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__pbase_type_info__masks();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/lib_src/rtti.c line 120
namespace stringify {
    const char* a_result_virtuality(int64_t);
 
    std::string a_result_virtuality(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_result_virtuality();
}
 
namespace Rose {
    std::string stringify_a_result_virtuality(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_result_virtuality();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/error.c line 91
namespace stringify {
    const char* a_diag_fill_in_kind(int64_t);
 
    std::string a_diag_fill_in_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_diag_fill_in_kind();
}
 
namespace Rose {
    std::string stringify_a_diag_fill_in_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diag_fill_in_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/error.c line 196
namespace stringify {
    const char* a_diagnostic_kind(int64_t);
 
    std::string a_diagnostic_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_diagnostic_kind();
}
 
namespace Rose {
    std::string stringify_a_diagnostic_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diagnostic_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/disp/decls.c line 16203
namespace stringify {
    const char* an_end_of_decl_action(int64_t);
 
    std::string an_end_of_decl_action(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_end_of_decl_action();
}
 
namespace Rose {
    std::string stringify_an_end_of_decl_action(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_end_of_decl_action();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/util/decode.c line 4297
namespace stringify {
    const char* a_substitution_kind(int64_t);
 
    std::string a_substitution_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_substitution_kind();
}
 
namespace Rose {
    std::string stringify_a_substitution_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_substitution_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/src/decls.h line 28
namespace stringify {
    const char* a_tu_decl_stage(int64_t);
 
    std::string a_tu_decl_stage(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_tu_decl_stage();
}
 
namespace Rose {
    std::string stringify_a_tu_decl_stage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_tu_decl_stage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/src/ifc_modules.h line 2968
namespace stringify { namespace an_ifc_module {
    const char* a_cache_expr_option(int64_t);
 
    std::string a_cache_expr_option(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cache_expr_option();
}}
 
namespace Rose {
    std::string stringify_an_ifc_module_a_cache_expr_option(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ifc_module_a_cache_expr_option();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/src/ifc_modules.h line 2977
namespace stringify { namespace an_ifc_module {
    const char* a_cache_statement_option(int64_t);
 
    std::string a_cache_statement_option(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cache_statement_option();
}}
 
namespace Rose {
    std::string stringify_an_ifc_module_a_cache_statement_option(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ifc_module_a_cache_statement_option();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-frontend-private.hpp line 151
namespace stringify { namespace ClangToSageTranslator {
    const char* Language(int64_t);
 
    std::string Language(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Language();
}}
 
namespace Rose {
    std::string stringifyClangToSageTranslatorLanguage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClangToSageTranslatorLanguage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-to-dot-private.hpp line 152
namespace stringify { namespace ClangToDotTranslator {
    const char* Language(int64_t);
 
    std::string Language(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Language();
}}
 
namespace Rose {
    std::string stringifyClangToDotTranslatorLanguage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClangToDotTranslatorLanguage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-to-dot-private.hpp line 223
namespace stringify { namespace ClangToDotTranslator { namespace ClangToDotTranslator {
    const char* Language(int64_t);
 
    std::string Language(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Language();
}}}
 
namespace Rose {
    std::string stringifyClangToDotTranslatorClangToDotTranslatorLanguage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClangToDotTranslatorClangToDotTranslatorLanguage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/Tokens.h line 18
namespace stringify { namespace Rose { namespace builder {
    const char* JovialEnum(int64_t);
 
    std::string JovialEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& JovialEnum();
}}}
 
namespace Rose {
    std::string stringify_builderJovialEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_builderJovialEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 14
namespace stringify { namespace LanguageTranslation {
    const char* FunctionModifier(int64_t);
 
    std::string FunctionModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FunctionModifier();
}}
 
namespace Rose {
    std::string stringifyLanguageTranslationFunctionModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLanguageTranslationFunctionModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 35
namespace stringify { namespace LanguageTranslation {
    const char* PackingSpecifier(int64_t);
 
    std::string PackingSpecifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PackingSpecifier();
}}
 
namespace Rose {
    std::string stringifyLanguageTranslationPackingSpecifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLanguageTranslationPackingSpecifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 45
namespace stringify { namespace LanguageTranslation {
    const char* ExpressionKind(int64_t);
 
    std::string ExpressionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ExpressionKind();
}}
 
namespace Rose {
    std::string stringifyLanguageTranslationExpressionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLanguageTranslationExpressionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 10
namespace stringify {
    const char* ROSE_Fortran_Identifiers(int64_t);
 
    std::string ROSE_Fortran_Identifiers(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Identifiers();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Identifiers(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Identifiers();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 140
namespace stringify {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 167
namespace stringify {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 14
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_keywords(int64_t);
 
    std::string ROSE_Fortran_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 147
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 215
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 242
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_operators(int64_t);
 
    std::string ROSE_C_CXX_operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_operators();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_C_CXX_operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 321
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 27
namespace stringify {
    const char* OpenMPDirectiveKind(int64_t);
 
    std::string OpenMPDirectiveKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDirectiveKind();
}
 
namespace Rose {
    std::string stringifyOpenMPDirectiveKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDirectiveKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 122
namespace stringify {
    const char* OpenMPClauseKind(int64_t);
 
    std::string OpenMPClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 237
namespace stringify {
    const char* OpenMPWhenClauseSelectorSet(int64_t);
 
    std::string OpenMPWhenClauseSelectorSet(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPWhenClauseSelectorSet();
}
 
namespace Rose {
    std::string stringifyOpenMPWhenClauseSelectorSet(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPWhenClauseSelectorSet();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 248
namespace stringify {
    const char* OpenMPWhenClauseSelectorParameter(int64_t);
 
    std::string OpenMPWhenClauseSelectorParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPWhenClauseSelectorParameter();
}
 
namespace Rose {
    std::string stringifyOpenMPWhenClauseSelectorParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPWhenClauseSelectorParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 257
namespace stringify {
    const char* OpenMPClauseContextKind(int64_t);
 
    std::string OpenMPClauseContextKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPClauseContextKind();
}
 
namespace Rose {
    std::string stringifyOpenMPClauseContextKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPClauseContextKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 270
namespace stringify {
    const char* OpenMPClauseContextVendor(int64_t);
 
    std::string OpenMPClauseContextVendor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPClauseContextVendor();
}
 
namespace Rose {
    std::string stringifyOpenMPClauseContextVendor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPClauseContextVendor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 291
namespace stringify {
    const char* OpenMPIfClauseModifier(int64_t);
 
    std::string OpenMPIfClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPIfClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPIfClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPIfClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 311
namespace stringify {
    const char* OpenMPDefaultClauseKind(int64_t);
 
    std::string OpenMPDefaultClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDefaultClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPDefaultClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDefaultClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 325
namespace stringify {
    const char* OpenMPOrderClauseKind(int64_t);
 
    std::string OpenMPOrderClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPOrderClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPOrderClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPOrderClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 335
namespace stringify {
    const char* OpenMPProcBindClauseKind(int64_t);
 
    std::string OpenMPProcBindClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPProcBindClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPProcBindClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPProcBindClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 346
namespace stringify {
    const char* OpenMPAllocateClauseAllocator(int64_t);
 
    std::string OpenMPAllocateClauseAllocator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPAllocateClauseAllocator();
}
 
namespace Rose {
    std::string stringifyOpenMPAllocateClauseAllocator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPAllocateClauseAllocator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 363
namespace stringify {
    const char* OpenMPAllocatorClauseAllocator(int64_t);
 
    std::string OpenMPAllocatorClauseAllocator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPAllocatorClauseAllocator();
}
 
namespace Rose {
    std::string stringifyOpenMPAllocatorClauseAllocator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPAllocatorClauseAllocator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 379
namespace stringify {
    const char* OpenMPReductionClauseModifier(int64_t);
 
    std::string OpenMPReductionClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPReductionClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPReductionClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPReductionClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 390
namespace stringify {
    const char* OpenMPReductionClauseIdentifier(int64_t);
 
    std::string OpenMPReductionClauseIdentifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPReductionClauseIdentifier();
}
 
namespace Rose {
    std::string stringifyOpenMPReductionClauseIdentifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPReductionClauseIdentifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 411
namespace stringify {
    const char* OpenMPLastprivateClauseModifier(int64_t);
 
    std::string OpenMPLastprivateClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPLastprivateClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPLastprivateClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPLastprivateClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 419
namespace stringify {
    const char* OpenMPLinearClauseStep(int64_t);
 
    std::string OpenMPLinearClauseStep(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPLinearClauseStep();
}
 
namespace Rose {
    std::string stringifyOpenMPLinearClauseStep(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPLinearClauseStep();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 430
namespace stringify {
    const char* OpenMPLinearClauseModifier(int64_t);
 
    std::string OpenMPLinearClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPLinearClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPLinearClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPLinearClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 444
namespace stringify {
    const char* OpenMPScheduleClauseModifier(int64_t);
 
    std::string OpenMPScheduleClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPScheduleClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPScheduleClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPScheduleClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 457
namespace stringify {
    const char* OpenMPScheduleClauseKind(int64_t);
 
    std::string OpenMPScheduleClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPScheduleClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPScheduleClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPScheduleClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 472
namespace stringify {
    const char* OpenMPDistScheduleClauseKind(int64_t);
 
    std::string OpenMPDistScheduleClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDistScheduleClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPDistScheduleClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDistScheduleClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 483
namespace stringify {
    const char* OpenMPBindClauseBinding(int64_t);
 
    std::string OpenMPBindClauseBinding(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPBindClauseBinding();
}
 
namespace Rose {
    std::string stringifyOpenMPBindClauseBinding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPBindClauseBinding();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 496
namespace stringify {
    const char* OpenMPInitializerClausePriv(int64_t);
 
    std::string OpenMPInitializerClausePriv(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPInitializerClausePriv();
}
 
namespace Rose {
    std::string stringifyOpenMPInitializerClausePriv(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPInitializerClausePriv();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 507
namespace stringify {
    const char* OpenMPAtomicDefaultMemOrderClauseKind(int64_t);
 
    std::string OpenMPAtomicDefaultMemOrderClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPAtomicDefaultMemOrderClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPAtomicDefaultMemOrderClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPAtomicDefaultMemOrderClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 518
namespace stringify {
    const char* OpenMPUsesAllocatorsClauseAllocator(int64_t);
 
    std::string OpenMPUsesAllocatorsClauseAllocator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPUsesAllocatorsClauseAllocator();
}
 
namespace Rose {
    std::string stringifyOpenMPUsesAllocatorsClauseAllocator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPUsesAllocatorsClauseAllocator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 535
namespace stringify {
    const char* OpenMPDeviceClauseModifier(int64_t);
 
    std::string OpenMPDeviceClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDeviceClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPDeviceClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDeviceClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 544
namespace stringify {
    const char* OpenMPInReductionClauseIdentifier(int64_t);
 
    std::string OpenMPInReductionClauseIdentifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPInReductionClauseIdentifier();
}
 
namespace Rose {
    std::string stringifyOpenMPInReductionClauseIdentifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPInReductionClauseIdentifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 564
namespace stringify {
    const char* OpenMPDependClauseModifier(int64_t);
 
    std::string OpenMPDependClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDependClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPDependClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDependClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 572
namespace stringify {
    const char* OpenMPDeclareMapperDirectiveIdentifier(int64_t);
 
    std::string OpenMPDeclareMapperDirectiveIdentifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDeclareMapperDirectiveIdentifier();
}
 
namespace Rose {
    std::string stringifyOpenMPDeclareMapperDirectiveIdentifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDeclareMapperDirectiveIdentifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 580
namespace stringify {
    const char* OpenMPDependClauseType(int64_t);
 
    std::string OpenMPDependClauseType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDependClauseType();
}
 
namespace Rose {
    std::string stringifyOpenMPDependClauseType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDependClauseType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 593
namespace stringify {
    const char* OpenMPAffinityClauseModifier(int64_t);
 
    std::string OpenMPAffinityClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPAffinityClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPAffinityClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPAffinityClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 600
namespace stringify {
    const char* OpenMPToClauseKind(int64_t);
 
    std::string OpenMPToClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPToClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPToClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPToClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 607
namespace stringify {
    const char* OpenMPFromClauseKind(int64_t);
 
    std::string OpenMPFromClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPFromClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPFromClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPFromClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 614
namespace stringify {
    const char* OpenMPDefaultmapClauseBehavior(int64_t);
 
    std::string OpenMPDefaultmapClauseBehavior(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDefaultmapClauseBehavior();
}
 
namespace Rose {
    std::string stringifyOpenMPDefaultmapClauseBehavior(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDefaultmapClauseBehavior();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 629
namespace stringify {
    const char* OpenMPDefaultmapClauseCategory(int64_t);
 
    std::string OpenMPDefaultmapClauseCategory(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDefaultmapClauseCategory();
}
 
namespace Rose {
    std::string stringifyOpenMPDefaultmapClauseCategory(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDefaultmapClauseCategory();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 641
namespace stringify {
    const char* OpenMPDeviceTypeClauseKind(int64_t);
 
    std::string OpenMPDeviceTypeClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDeviceTypeClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenMPDeviceTypeClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDeviceTypeClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 650
namespace stringify {
    const char* OpenMPMapClauseModifier(int64_t);
 
    std::string OpenMPMapClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPMapClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenMPMapClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPMapClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 658
namespace stringify {
    const char* OpenMPMapClauseType(int64_t);
 
    std::string OpenMPMapClauseType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPMapClauseType();
}
 
namespace Rose {
    std::string stringifyOpenMPMapClauseType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPMapClauseType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 670
namespace stringify {
    const char* OpenMPTaskReductionClauseIdentifier(int64_t);
 
    std::string OpenMPTaskReductionClauseIdentifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPTaskReductionClauseIdentifier();
}
 
namespace Rose {
    std::string stringifyOpenMPTaskReductionClauseIdentifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPTaskReductionClauseIdentifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPKinds.h line 689
namespace stringify {
    const char* OpenMPDepobjUpdateClauseDependeceType(int64_t);
 
    std::string OpenMPDepobjUpdateClauseDependeceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPDepobjUpdateClauseDependeceType();
}
 
namespace Rose {
    std::string stringifyOpenMPDepobjUpdateClauseDependeceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPDepobjUpdateClauseDependeceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompparser/src/OpenMPIR.h line 25
namespace stringify {
    const char* OpenMPBaseLang(int64_t);
 
    std::string OpenMPBaseLang(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenMPBaseLang();
}
 
namespace Rose {
    std::string stringifyOpenMPBaseLang(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenMPBaseLang();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCIR.h line 10
namespace stringify {
    const char* OpenACCBaseLang(int64_t);
 
    std::string OpenACCBaseLang(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCBaseLang();
}
 
namespace Rose {
    std::string stringifyOpenACCBaseLang(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCBaseLang();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 11
namespace stringify {
    const char* OpenACCDirectiveKind(int64_t);
 
    std::string OpenACCDirectiveKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCDirectiveKind();
}
 
namespace Rose {
    std::string stringifyOpenACCDirectiveKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCDirectiveKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 40
namespace stringify {
    const char* OpenACCClauseKind(int64_t);
 
    std::string OpenACCClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenACCClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 93
namespace stringify {
    const char* OpenACCCacheDirectiveModifier(int64_t);
 
    std::string OpenACCCacheDirectiveModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCCacheDirectiveModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCCacheDirectiveModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCCacheDirectiveModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 102
namespace stringify {
    const char* OpenACCCopyinClauseModifier(int64_t);
 
    std::string OpenACCCopyinClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCCopyinClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCCopyinClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCCopyinClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 111
namespace stringify {
    const char* OpenACCCopyoutClauseModifier(int64_t);
 
    std::string OpenACCCopyoutClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCCopyoutClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCCopyoutClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCCopyoutClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 120
namespace stringify {
    const char* OpenACCCreateClauseModifier(int64_t);
 
    std::string OpenACCCreateClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCCreateClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCCreateClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCCreateClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 129
namespace stringify {
    const char* OpenACCDefaultClauseKind(int64_t);
 
    std::string OpenACCDefaultClauseKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCDefaultClauseKind();
}
 
namespace Rose {
    std::string stringifyOpenACCDefaultClauseKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCDefaultClauseKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 139
namespace stringify {
    const char* OpenACCReductionClauseOperator(int64_t);
 
    std::string OpenACCReductionClauseOperator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCReductionClauseOperator();
}
 
namespace Rose {
    std::string stringifyOpenACCReductionClauseOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCReductionClauseOperator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 157
namespace stringify {
    const char* OpenACCVectorClauseModifier(int64_t);
 
    std::string OpenACCVectorClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCVectorClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCVectorClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCVectorClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/accparser/src/OpenACCKinds.h line 166
namespace stringify {
    const char* OpenACCWorkerClauseModifier(int64_t);
 
    std::string OpenACCWorkerClauseModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpenACCWorkerClauseModifier();
}
 
namespace Rose {
    std::string stringifyOpenACCWorkerClauseModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpenACCWorkerClauseModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 31
namespace stringify {
    const char* omp_lock_hint_t(int64_t);
 
    std::string omp_lock_hint_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_lock_hint_t();
}
 
namespace Rose {
    std::string stringify_omp_lock_hint_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_lock_hint_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 47
namespace stringify {
    const char* omp_sched_t(int64_t);
 
    std::string omp_sched_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_sched_t();
}
 
namespace Rose {
    std::string stringify_omp_sched_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_sched_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 58
namespace stringify {
    const char* omp_proc_bind_t(int64_t);
 
    std::string omp_proc_bind_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_proc_bind_t();
}
 
namespace Rose {
    std::string stringify_omp_proc_bind_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_proc_bind_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/sageInterface/sageBuilder.h line 138
namespace stringify { namespace SageBuilder {
    const char* SourcePositionClassification(int64_t);
 
    std::string SourcePositionClassification(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SourcePositionClassification();
}}
 
namespace Rose {
    std::string stringifySageBuilderSourcePositionClassification(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySageBuilderSourcePositionClassification();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/sageInterface/sageInterface.h line 1826
namespace stringify { namespace SageInterface { namespace DeferredTransformation {
    const char* TransformationKind(int64_t);
 
    std::string TransformationKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TransformationKind();
}}}
 
namespace Rose {
    std::string stringifySageInterfaceDeferredTransformationTransformationKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySageInterfaceDeferredTransformationTransformationKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 133
namespace stringify { namespace PreprocessingInfo {
    const char* RelativePositionType(int64_t);
 
    std::string RelativePositionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RelativePositionType();
}}
 
namespace Rose {
    std::string stringifyPreprocessingInfoRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoRelativePositionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 154
namespace stringify { namespace PreprocessingInfo {
    const char* DirectiveType(int64_t);
 
    std::string DirectiveType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DirectiveType();
}}
 
namespace Rose {
    std::string stringifyPreprocessingInfoDirectiveType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoDirectiveType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 532
namespace stringify { namespace ROSEAttributesList {
    const char* languageTypeEnum(int64_t);
 
    std::string languageTypeEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& languageTypeEnum();
}}
 
namespace Rose {
    std::string stringifyROSEAttributesList_languageTypeEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSEAttributesList_languageTypeEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 12
namespace stringify { namespace ROSE_token_ids {
    const char* whitespace(int64_t);
 
    std::string whitespace(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& whitespace();
}}
 
namespace Rose {
    std::string stringifyROSE_token_ids_whitespace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_ids_whitespace();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 21
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 159
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_alternate_tok(int64_t);
 
    std::string ROSE_C_CXX_alternate_tok(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_alternate_tok();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_alternate_tok(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_alternate_tok();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 171
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_Additional_Info(int64_t);
 
    std::string ROSE_C_CXX_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_Additional_Info();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/ompSupport.h line 32
namespace stringify { namespace OmpSupport {
    const char* omp_construct_enum(int64_t);
 
    std::string omp_construct_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_construct_enum();
}}
 
namespace Rose {
    std::string stringifyOmpSupport_omp_construct_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOmpSupport_omp_construct_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 12
namespace stringify { namespace AST_Graph {
    const char* pointerHandling(int64_t);
 
    std::string pointerHandling(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& pointerHandling();
}}
 
namespace Rose {
    std::string stringifyAST_Graph_pointerHandling(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_pointerHandling();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 19
namespace stringify { namespace AST_Graph {
    const char* traversalType(int64_t);
 
    std::string traversalType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& traversalType();
}}
 
namespace Rose {
    std::string stringifyAST_Graph_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_traversalType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 25
namespace stringify { namespace AstAttributeDOT {
    const char* DOTStyles(int64_t);
 
    std::string DOTStyles(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTStyles();
}}
 
namespace Rose {
    std::string stringifyAstAttributeDOT_DOTStyles(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstAttributeDOT_DOTStyles();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 90
namespace stringify { namespace DOTGraphNode {
    const char* DOTShapeTypes(int64_t);
 
    std::string DOTShapeTypes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTShapeTypes();
}}
 
namespace Rose {
    std::string stringifyDOTGraphNodeDOTShapeTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphNodeDOTShapeTypes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 137
namespace stringify { namespace DOTGraphEdge {
    const char* DOTArrowTypes(int64_t);
 
    std::string DOTArrowTypes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTArrowTypes();
}}
 
namespace Rose {
    std::string stringifyDOTGraphEdgeDOTArrowTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphEdgeDOTArrowTypes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/virtualCFG/virtualCFG.h line 47
namespace stringify { namespace VirtualCFG {
    const char* EdgeConditionKind(int64_t);
 
    std::string EdgeConditionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeConditionKind();
}}
 
namespace Rose {
    std::string stringifyVirtualCFG_EdgeConditionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVirtualCFG_EdgeConditionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 100
namespace stringify { namespace AstNodeClass {
    const char* locationInTree(int64_t);
 
    std::string locationInTree(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& locationInTree();
}}
 
namespace Rose {
    std::string stringifyAstNodeClass_locationInTree(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_locationInTree();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 106
namespace stringify { namespace AstNodeClass {
    const char* includeExcludeMechanism(int64_t);
 
    std::string includeExcludeMechanism(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& includeExcludeMechanism();
}}
 
namespace Rose {
    std::string stringifyAstNodeClass_includeExcludeMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 309
namespace stringify { namespace AstNodeClass {
    const char* TypeEvaluation(int64_t);
 
    std::string TypeEvaluation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeEvaluation();
}}
 
namespace Rose {
    std::string stringifyAstNodeClassTypeEvaluation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 82
namespace stringify {
    const char* ConstructParamEnum(int64_t);
 
    std::string ConstructParamEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ConstructParamEnum();
}
 
namespace Rose {
    std::string stringifyConstructParamEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstructParamEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 87
namespace stringify {
    const char* BuildAccessEnum(int64_t);
 
    std::string BuildAccessEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& BuildAccessEnum();
}
 
namespace Rose {
    std::string stringifyBuildAccessEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBuildAccessEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 95
namespace stringify {
    const char* CopyConfigEnum(int64_t);
 
    std::string CopyConfigEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CopyConfigEnum();
}
 
namespace Rose {
    std::string stringifyCopyConfigEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCopyConfigEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 116
namespace stringify {
    const char* TraversalEnum(int64_t);
 
    std::string TraversalEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEnum();
}
 
namespace Rose {
    std::string stringifyTraversalEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTraversalEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 121
namespace stringify {
    const char* DeleteEnum(int64_t);
 
    std::string DeleteEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DeleteEnum();
}
 
namespace Rose {
    std::string stringifyDeleteEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDeleteEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 25
namespace stringify { namespace Rose { namespace StringUtility {
    const char* OSType(int64_t);
 
    std::string OSType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OSType();
}}}
 
namespace Rose {
    std::string stringifyStringUtilityOSType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityOSType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 150
namespace stringify { namespace Rose { namespace StringUtility {
    const char* FileNameLocation(int64_t);
 
    std::string FileNameLocation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FileNameLocation();
}}}
 
namespace Rose {
    std::string stringifyStringUtilityFileNameLocation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityFileNameLocation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 173
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SortOrder(int64_t);
 
    std::string SortOrder(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SortOrder();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineSortOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSortOrder();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 186
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* Canonical(int64_t);
 
    std::string Canonical(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Canonical();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineCanonical(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineCanonical();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 194
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* ShowGroupName(int64_t);
 
    std::string ShowGroupName(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ShowGroupName();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineShowGroupName(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineShowGroupName();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 202
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SwitchSkipping(int64_t);
 
    std::string SwitchSkipping(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SwitchSkipping();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineSwitchSkipping(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSwitchSkipping();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 2010
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* WhichValue(int64_t);
 
    std::string WhichValue(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WhichValue();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineWhichValue(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineWhichValue();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 3065
namespace stringify { namespace Sawyer { namespace CommandLine { namespace Parser {
    const char* GroupingFlags(int64_t);
 
    std::string GroupingFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GroupingFlags();
}}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineParserGroupingFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineParserGroupingFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Clexer.h line 25
namespace stringify { namespace Sawyer { namespace Language { namespace Clexer {
    const char* TokenType(int64_t);
 
    std::string TokenType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TokenType();
}}}}
 
namespace Rose {
    std::string stringifySawyerLanguageClexerTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerLanguageClexerTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Graph.h line 636
namespace stringify { namespace Sawyer { namespace Container { namespace Graph {
    const char* EdgePhase(int64_t);
 
    std::string EdgePhase(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgePhase();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerGraphEdgePhase(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerGraphEdgePhase();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/DocumentMarkup.h line 42
namespace stringify { namespace Sawyer { namespace Document { namespace Markup {
    const char* TokenType(int64_t);
 
    std::string TokenType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TokenType();
}}}}
 
namespace Rose {
    std::string stringifySawyerDocumentMarkupTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerDocumentMarkupTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Access.h line 19
namespace stringify { namespace Sawyer { namespace Access {
    const char* Access(int64_t);
 
    std::string Access(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Access();
}}}
 
namespace Rose {
    std::string stringifySawyerAccessAccess(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerAccessAccess();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/GraphAlgorithm.h line 374
namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
    const char* CsiNextAction(int64_t);
 
    std::string CsiNextAction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CsiNextAction();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerAlgorithmCsiNextAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmCsiNextAction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/stringifyEnums.C line 39
namespace stringify {
    const char* Generate(int64_t);
 
    std::string Generate(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Generate();
}
 
namespace Rose {
    std::string stringifyGenerate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyGenerate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/stringifyEnums.C line 46
namespace stringify {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}
 
namespace Rose {
    std::string stringifyFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 313
namespace stringify { namespace Sawyer { namespace Message {
    const char* Importance(int64_t);
 
    std::string Importance(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Importance();
}}}
 
namespace Rose {
    std::string stringifySawyerMessageImportance(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageImportance();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 343
namespace stringify { namespace Sawyer { namespace Message {
    const char* AnsiColor(int64_t);
 
    std::string AnsiColor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AnsiColor();
}}}
 
namespace Rose {
    std::string stringifySawyerMessageAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageAnsiColor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 990
namespace stringify { namespace Sawyer { namespace Message { namespace Prefix {
    const char* When(int64_t);
 
    std::string When(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& When();
}}}}
 
namespace Rose {
    std::string stringifySawyerMessagePrefixWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessagePrefixWhen();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/GraphTraversal.h line 39
namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
    const char* TraversalEvent(int64_t);
 
    std::string TraversalEvent(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEvent();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerAlgorithmTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmTraversalEvent();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 119
namespace stringify { namespace Sawyer { namespace Tree {
    const char* TraversalEvent(int64_t);
 
    std::string TraversalEvent(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEvent();
}}}
 
namespace Rose {
    std::string stringifySawyerTreeTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeTraversalEvent();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 125
namespace stringify { namespace Sawyer { namespace Tree {
    const char* TraversalAction(int64_t);
 
    std::string TraversalAction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalAction();
}}}
 
namespace Rose {
    std::string stringifySawyerTreeTraversalAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeTraversalAction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 481
namespace stringify { namespace Sawyer { namespace Tree { namespace Node {
    const char* TraversalDirection(int64_t);
 
    std::string TraversalDirection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalDirection();
}}}}
 
namespace Rose {
    std::string stringifySawyerTreeNodeTraversalDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeNodeTraversalDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 19
namespace stringify {
    const char* AssociativitySpecifier(int64_t);
 
    std::string AssociativitySpecifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AssociativitySpecifier();
}
 
namespace Rose {
    std::string stringifyAssociativitySpecifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAssociativitySpecifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 46
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* token_sequence_position_enum_type(int64_t);
 
    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_sequence_position_enum_type();
}}
 
namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 74
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* unparsed_as_enum_type(int64_t);
 
    std::string unparsed_as_enum_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& unparsed_as_enum_type();
}}
 
namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 543
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(int64_t);
 
    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_sequence_position_enum_type();
}}
 
namespace Rose {
    std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/unparser.h line 199
namespace stringify { namespace Unparser {
    const char* token_sequence_position_enum_type(int64_t);
 
    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_sequence_position_enum_type();
}}
 
namespace Rose {
    std::string stringifyUnparser_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/astUnparseAttribute.h line 33
namespace stringify { namespace AstUnparseAttribute {
    const char* RelativePositionType(int64_t);
 
    std::string RelativePositionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RelativePositionType();
}}
 
namespace Rose {
    std::string stringifyAstUnparseAttributeRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/formatSupport/unparse_format.h line 51
namespace stringify {
    const char* Format_Opt(int64_t);
 
    std::string Format_Opt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Format_Opt();
}
 
namespace Rose {
    std::string stringifyFormat_Opt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormat_Opt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 4744
namespace stringify { namespace nlohmann { namespace detail {
    const char* input_format_t(int64_t);
 
    std::string input_format_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& input_format_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_input_format_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_input_format_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 5909
namespace stringify { namespace nlohmann { namespace detail { namespace lexer_base {
    const char* token_type(int64_t);
 
    std::string token_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_type();
}}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_lexer_base_token_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_lexer_base_token_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 7668
namespace stringify { namespace nlohmann { namespace detail {
    const char* cbor_tag_handler_t(int64_t);
 
    std::string cbor_tag_handler_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cbor_tag_handler_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_cbor_tag_handler_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_cbor_tag_handler_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 15469
namespace stringify { namespace nlohmann { namespace detail {
    const char* error_handler_t(int64_t);
 
    std::string error_handler_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& error_handler_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_error_handler_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_error_handler_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 24668
namespace stringify { namespace nlohmann { namespace basic_json {
    const char* patch_operations(int64_t);
 
    std::string patch_operations(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& patch_operations();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_basic_json_patch_operations(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_basic_json_patch_operations();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/MSTL/DOTGeneration.h line 48
namespace stringify { namespace DOTGeneration {
    const char* traversalType(int64_t);
 
    std::string traversalType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& traversalType();
}}
 
namespace Rose {
    std::string stringifyDOTGeneration_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGeneration_traversalType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_font.h line 31
namespace stringify {
    const char* _HPDF_FontType(int64_t);
 
    std::string _HPDF_FontType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_FontType();
}
 
namespace Rose {
    std::string stringify_HPDF_FontType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_FontType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_fontdef.h line 63
namespace stringify {
    const char* _HPDF_FontDefType(int64_t);
 
    std::string _HPDF_FontDefType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_FontDefType();
}
 
namespace Rose {
    std::string stringify_HPDF_FontDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_FontDefType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 128
namespace stringify {
    const char* _HPDF_InfoType(int64_t);
 
    std::string _HPDF_InfoType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_InfoType();
}
 
namespace Rose {
    std::string stringify_HPDF_InfoType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_InfoType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 144
namespace stringify {
    const char* _HPDF_PdfVer(int64_t);
 
    std::string _HPDF_PdfVer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PdfVer();
}
 
namespace Rose {
    std::string stringify_HPDF_PdfVer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PdfVer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 154
namespace stringify {
    const char* _HPDF_EncryptMode(int64_t);
 
    std::string _HPDF_EncryptMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_EncryptMode();
}
 
namespace Rose {
    std::string stringify_HPDF_EncryptMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncryptMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 213
namespace stringify {
    const char* _HPDF_ColorSpace(int64_t);
 
    std::string _HPDF_ColorSpace(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_ColorSpace();
}
 
namespace Rose {
    std::string stringify_HPDF_ColorSpace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_ColorSpace();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 250
namespace stringify {
    const char* _HPDF_LineCap(int64_t);
 
    std::string _HPDF_LineCap(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_LineCap();
}
 
namespace Rose {
    std::string stringify_HPDF_LineCap(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_LineCap();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 260
namespace stringify {
    const char* _HPDF_LineJoin(int64_t);
 
    std::string _HPDF_LineJoin(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_LineJoin();
}
 
namespace Rose {
    std::string stringify_HPDF_LineJoin(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_LineJoin();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 270
namespace stringify {
    const char* _HPDF_TextRenderingMode(int64_t);
 
    std::string _HPDF_TextRenderingMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_TextRenderingMode();
}
 
namespace Rose {
    std::string stringify_HPDF_TextRenderingMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TextRenderingMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 283
namespace stringify {
    const char* _HPDF_WritingMode(int64_t);
 
    std::string _HPDF_WritingMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_WritingMode();
}
 
namespace Rose {
    std::string stringify_HPDF_WritingMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_WritingMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 290
namespace stringify {
    const char* _HPDF_PageLayout(int64_t);
 
    std::string _HPDF_PageLayout(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PageLayout();
}
 
namespace Rose {
    std::string stringify_HPDF_PageLayout(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageLayout();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 299
namespace stringify {
    const char* _HPDF_PageMode(int64_t);
 
    std::string _HPDF_PageMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PageMode();
}
 
namespace Rose {
    std::string stringify_HPDF_PageMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 311
namespace stringify {
    const char* _HPDF_PageNumStyle(int64_t);
 
    std::string _HPDF_PageNumStyle(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PageNumStyle();
}
 
namespace Rose {
    std::string stringify_HPDF_PageNumStyle(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageNumStyle();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 321
namespace stringify {
    const char* _HPDF_DestinationType(int64_t);
 
    std::string _HPDF_DestinationType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_DestinationType();
}
 
namespace Rose {
    std::string stringify_HPDF_DestinationType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_DestinationType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 334
namespace stringify {
    const char* _HPDF_AnnotType(int64_t);
 
    std::string _HPDF_AnnotType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_AnnotType();
}
 
namespace Rose {
    std::string stringify_HPDF_AnnotType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 352
namespace stringify {
    const char* _HPDF_AnnotFlgs(int64_t);
 
    std::string _HPDF_AnnotFlgs(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_AnnotFlgs();
}
 
namespace Rose {
    std::string stringify_HPDF_AnnotFlgs(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotFlgs();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 363
namespace stringify {
    const char* _HPDF_AnnotHighlightMode(int64_t);
 
    std::string _HPDF_AnnotHighlightMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_AnnotHighlightMode();
}
 
namespace Rose {
    std::string stringify_HPDF_AnnotHighlightMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotHighlightMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 372
namespace stringify {
    const char* _HPDF_AnnotIcon(int64_t);
 
    std::string _HPDF_AnnotIcon(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_AnnotIcon();
}
 
namespace Rose {
    std::string stringify_HPDF_AnnotIcon(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotIcon();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 388
namespace stringify {
    const char* _HPDF_BSSubtype(int64_t);
 
    std::string _HPDF_BSSubtype(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_BSSubtype();
}
 
namespace Rose {
    std::string stringify_HPDF_BSSubtype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BSSubtype();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 399
namespace stringify {
    const char* _HPDF_BlendMode(int64_t);
 
    std::string _HPDF_BlendMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_BlendMode();
}
 
namespace Rose {
    std::string stringify_HPDF_BlendMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BlendMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 417
namespace stringify {
    const char* _HPDF_TransitionStyle(int64_t);
 
    std::string _HPDF_TransitionStyle(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_TransitionStyle();
}
 
namespace Rose {
    std::string stringify_HPDF_TransitionStyle(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TransitionStyle();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 440
namespace stringify {
    const char* _HPDF_PageSizes(int64_t);
 
    std::string _HPDF_PageSizes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PageSizes();
}
 
namespace Rose {
    std::string stringify_HPDF_PageSizes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageSizes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 457
namespace stringify {
    const char* _HPDF_PageDirection(int64_t);
 
    std::string _HPDF_PageDirection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_PageDirection();
}
 
namespace Rose {
    std::string stringify_HPDF_PageDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 463
namespace stringify {
    const char* _HPDF_EncoderType(int64_t);
 
    std::string _HPDF_EncoderType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_EncoderType();
}
 
namespace Rose {
    std::string stringify_HPDF_EncoderType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncoderType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 471
namespace stringify {
    const char* _HPDF_ByteType(int64_t);
 
    std::string _HPDF_ByteType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_ByteType();
}
 
namespace Rose {
    std::string stringify_HPDF_ByteType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_ByteType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 479
namespace stringify {
    const char* _HPDF_TextAlignment(int64_t);
 
    std::string _HPDF_TextAlignment(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_TextAlignment();
}
 
namespace Rose {
    std::string stringify_HPDF_TextAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TextAlignment();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 33
namespace stringify {
    const char* _HPDF_StreamType(int64_t);
 
    std::string _HPDF_StreamType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_StreamType();
}
 
namespace Rose {
    std::string stringify_HPDF_StreamType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_StreamType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 46
namespace stringify {
    const char* _HPDF_WhenceMode(int64_t);
 
    std::string _HPDF_WhenceMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_WhenceMode();
}
 
namespace Rose {
    std::string stringify_HPDF_WhenceMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_WhenceMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 69
namespace stringify {
    const char* _HPDF_EncodingType(int64_t);
 
    std::string _HPDF_EncodingType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_EncodingType();
}
 
namespace Rose {
    std::string stringify_HPDF_EncodingType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncodingType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 130
namespace stringify {
    const char* _HPDF_BaseEncodings(int64_t);
 
    std::string _HPDF_BaseEncodings(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _HPDF_BaseEncodings();
}
 
namespace Rose {
    std::string stringify_HPDF_BaseEncodings(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BaseEncodings();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Yaml.h line 154
namespace stringify { namespace Rose { namespace Yaml { namespace Exception {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifyYamlException_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyYamlException_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Yaml.h line 259
namespace stringify { namespace Rose { namespace Yaml { namespace Iterator {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifyYamlIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyYamlIterator_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Yaml.h line 316
namespace stringify { namespace Rose { namespace Yaml { namespace ConstIterator {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifyYamlConstIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyYamlConstIterator_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Yaml.h line 333
namespace stringify { namespace Rose { namespace Yaml { namespace Node {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifyYamlNode_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyYamlNode_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/CommandLine/SuffixMultiplierParser.h line 36
namespace stringify { namespace Rose { namespace CommandLine { namespace SuffixMultiplierParser {
    const char* Preferred(int64_t);
 
    std::string Preferred(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Preferred();
}}}}
 
namespace Rose {
    std::string stringifyCommandLineSuffixMultiplierParserPreferred(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCommandLineSuffixMultiplierParserPreferred();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/CodeGen/Object.h line 11
namespace stringify { namespace Rose { namespace CodeGen {
    const char* Object(int64_t);
 
    std::string Object(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Object();
}}}
 
namespace Rose {
    std::string stringifyCodeGenObject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeGenObject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 22
namespace stringify { namespace Rose { namespace Color { namespace Enabled {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}}}}
 
namespace Rose {
    std::string stringifyColorEnabledFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorEnabledFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 33
namespace stringify { namespace Rose { namespace Color { namespace Theme {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}}}}
 
namespace Rose {
    std::string stringifyColorThemeFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorThemeFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 53
namespace stringify { namespace Rose { namespace Color { namespace Layer {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}}}}
 
namespace Rose {
    std::string stringifyColorLayerFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorLayerFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 359
namespace stringify { namespace Rose { namespace Color {
    const char* AnsiColor(int64_t);
 
    std::string AnsiColor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AnsiColor();
}}}
 
namespace Rose {
    std::string stringifyColorAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorAnsiColor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Yaml.C line 1210
namespace stringify { namespace Rose { namespace Yaml { namespace ReaderLine {
    const char* eFlag(int64_t);
 
    std::string eFlag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eFlag();
}}}}
 
namespace Rose {
    std::string stringifyYamlReaderLine_eFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyYamlReaderLine_eFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 25
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace graphviz_t {
    const char* Mode(int64_t);
 
    std::string Mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Mode();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_graphviz_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_graphviz_tMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 43
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
    const char* Mode(int64_t);
 
    std::string Mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Mode();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_checker_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_checker_tMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 54
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
    const char* Effect(int64_t);
 
    std::string Effect(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Effect();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_checker_tEffect(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_checker_tEffect();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/Defect.h line 19
namespace stringify { namespace Rose { namespace AST { namespace Defects {
    const char* Kind(int64_t);
 
    std::string Kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Kind();
}}}}
 
namespace Rose {
    std::string stringifyAST_DefectsKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_DefectsKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/Defect.h line 97
namespace stringify { namespace Rose { namespace AST { namespace Defects {
    const char* Reason(int64_t);
 
    std::string Reason(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Reason();
}}}}
 
namespace Rose {
    std::string stringifyAST_DefectsReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_DefectsReason();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/FormattedTable.h line 22
namespace stringify { namespace Rose { namespace FormattedTable {
    const char* Format(int64_t);
 
    std::string Format(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Format();
}}}
 
namespace Rose {
    std::string stringifyFormattedTableFormat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormattedTableFormat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/FormattedTable.h line 35
namespace stringify { namespace Rose { namespace FormattedTable {
    const char* Alignment(int64_t);
 
    std::string Alignment(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Alignment();
}}}
 
namespace Rose {
    std::string stringifyFormattedTableAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormattedTableAlignment();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractMemoryObject/memory_object_impl.h line 84
namespace stringify { namespace AbstractMemoryObject { namespace IndexSet {
    const char* Index_type(int64_t);
 
    std::string Index_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Index_type();
}}}
 
namespace Rose {
    std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/extractFunctionArgumentsNormalization/functionEvaluationOrderTraversal.h line 40
namespace stringify { namespace FunctionCallInfo {
    const char* InsertionMode(int64_t);
 
    std::string InsertionMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InsertionMode();
}}
 
namespace Rose {
    std::string stringifyFunctionCallInfoInsertionMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/omp_lowering.h line 41
namespace stringify { namespace OmpSupport {
    const char* omp_rtl_enum(int64_t);
 
    std::string omp_rtl_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_rtl_enum();
}}
 
namespace Rose {
    std::string stringifyOmpSupport_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/rex_llvm.h line 2
namespace stringify {
    const char* tgt_map_type(int64_t);
 
    std::string tgt_map_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& tgt_map_type();
}
 
namespace Rose {
    std::string stringify_tgt_map_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_tgt_map_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/rex_llvm.h line 35
namespace stringify {
    const char* kmp_sched_t(int64_t);
 
    std::string kmp_sched_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& kmp_sched_t();
}
 
namespace Rose {
    std::string stringify_kmp_sched_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_kmp_sched_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/omp_simd.h line 3
namespace stringify {
    const char* SimdType(int64_t);
 
    std::string SimdType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SimdType();
}
 
namespace Rose {
    std::string stringifySimdType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySimdType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/omp_simd.h line 11
namespace stringify {
    const char* OpType(int64_t);
 
    std::string OpType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OpType();
}
 
namespace Rose {
    std::string stringifyOpType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOpType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/xomp.c line 63
namespace stringify {
    const char* omp_rtl_enum(int64_t);
 
    std::string omp_rtl_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_rtl_enum();
}
 
namespace Rose {
    std::string stringify_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_rtl_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/implicitCodeGeneration/defaultFunctionGenerator.C line 17
namespace stringify {
    const char* defaultEnumFunctionType(int64_t);
 
    std::string defaultEnumFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& defaultEnumFunctionType();
}
 
namespace Rose {
    std::string stringify_defaultEnumFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_defaultEnumFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 52
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(int64_t);
 
    std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ScopeIdentifier_Enum();
}}
 
namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 66
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(int64_t);
 
    std::string PlacementPosition_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PlacementPosition_Enum();
}}
 
namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 79
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(int64_t);
 
    std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
}}
 
namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 141
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(int64_t);
 
    std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ScopeIdentifier_Enum();
}}
 
namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 162
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(int64_t);
 
    std::string PlacementPosition_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PlacementPosition_Enum();
}}
 
namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 176
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(int64_t);
 
    std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
}}
 
namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.C line 21
namespace stringify {
    const char* WarningType(int64_t);
 
    std::string WarningType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WarningType();
}
 
namespace Rose {
    std::string stringifyWarningType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyWarningType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.h line 40
namespace stringify { namespace AstAttribute {
    const char* OwnershipPolicy(int64_t);
 
    std::string OwnershipPolicy(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OwnershipPolicy();
}}
 
namespace Rose {
    std::string stringifyAstAttributeOwnershipPolicy(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstAttributeOwnershipPolicy();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 21
namespace stringify { namespace SDG { namespace SDGNode {
    const char* NodeType(int64_t);
 
    std::string NodeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NodeType();
}}}
 
namespace Rose {
    std::string stringifySDG_SDGNodeNodeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGNodeNodeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 48
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* EdgeType(int64_t);
 
    std::string EdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeType();
}}}
 
namespace Rose {
    std::string stringifySDG_SDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGEdgeEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 58
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* ControlDependenceType(int64_t);
 
    std::string ControlDependenceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ControlDependenceType();
}}}
 
namespace Rose {
    std::string stringifySDG_SDGEdgeControlDependenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGEdgeControlDependenceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/PDG.h line 32
namespace stringify { namespace SDG { namespace PDGEdge {
    const char* EdgeType(int64_t);
 
    std::string EdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeType();
}}}
 
namespace Rose {
    std::string stringifySDG_PDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_PDGEdgeEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/lattice/ConstrGraph.h line 45
namespace stringify { namespace ConstrGraph {
    const char* levels(int64_t);
 
    std::string levels(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& levels();
}}
 
namespace Rose {
    std::string stringifyConstrGraph_levels(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstrGraph_levels();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/simpleAnalyses/taintAnalysis.h line 63
namespace stringify { namespace TaintLattice {
    const char* Vertex(int64_t);
 
    std::string Vertex(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Vertex();
}}
 
namespace Rose {
    std::string stringifyTaintLatticeVertex(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTaintLatticeVertex();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/cfgUtils/CallGraphTraverse.h line 124
namespace stringify { namespace CGFunction { namespace iterator {
    const char* direction(int64_t);
 
    std::string direction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& direction();
}}}
 
namespace Rose {
    std::string stringifyCGFunction_iterator_direction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCGFunction_iterator_direction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominatorTreesAndDominanceFrontiers/DominatorTree.h line 50
namespace stringify { namespace DominatorTreesAndDominanceFrontiers { namespace DominatorTree {
    const char* Direction(int64_t);
 
    std::string Direction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Direction();
}}}
 
namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ssaUnfilteredCfg/reachingDefUnfilteredCfg.h line 19
namespace stringify { namespace ssa_unfiltered_cfg { namespace ReachingDef {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_ssa_unfiltered_cfgReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_ssa_unfiltered_cfgReachingDefType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 163
namespace stringify {
    const char* IRProcType(int64_t);
 
    std::string IRProcType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IRProcType();
}
 
namespace Rose {
    std::string stringifyIRProcType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRProcType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 173
namespace stringify {
    const char* IRStmtType(int64_t);
 
    std::string IRStmtType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IRStmtType();
}
 
namespace Rose {
    std::string stringifyIRStmtType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRStmtType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CallGraph/CallGraph.h line 73
namespace stringify { namespace CallGraph {
    const char* EdgeType(int64_t);
 
    std::string EdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeType();
}}
 
namespace Rose {
    std::string stringifyCallGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCallGraphEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/CFG.h line 83
namespace stringify { namespace CFG {
    const char* EdgeType(int64_t);
 
    std::string EdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeType();
}}
 
namespace Rose {
    std::string stringifyCFG_EdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCFG_EdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 65
namespace stringify {
    const char* RITarjType(int64_t);
 
    std::string RITarjType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RITarjType();
}
 
namespace Rose {
    std::string stringifyRITarjType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRITarjType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 67
namespace stringify {
    const char* RITarjEdgeType(int64_t);
 
    std::string RITarjEdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RITarjEdgeType();
}
 
namespace Rose {
    std::string stringifyRITarjEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRITarjEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 63
namespace stringify { namespace RIFG {
    const char* EdgeDirection(int64_t);
 
    std::string EdgeDirection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeDirection();
}}
 
namespace Rose {
    std::string stringifyRIFG_EdgeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRIFG_EdgeDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 64
namespace stringify { namespace RIFG {
    const char* ForwardBackward(int64_t);
 
    std::string ForwardBackward(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ForwardBackward();
}}
 
namespace Rose {
    std::string stringifyRIFG_ForwardBackward(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRIFG_ForwardBackward();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Utils/BaseGraph.h line 261
namespace stringify { namespace BaseGraph { namespace BiDirNodesIterator {
    const char* dirType(int64_t);
 
    std::string dirType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& dirType();
}}}
 
namespace Rose {
    std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominanceAnalysis/DominatorTree.h line 13
namespace stringify { namespace DominatorTreesAndDominanceFrontiers {
    const char* Dir_ection(int64_t);
 
    std::string Dir_ection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Dir_ection();
}}
 
namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 25
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* running_mode_enum(int64_t);
 
    std::string running_mode_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& running_mode_enum();
}}
 
namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_running_mode_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 30
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* fp_operation_kind_enum(int64_t);
 
    std::string fp_operation_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& fp_operation_kind_enum();
}}
 
namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/staticSingleAssignment/reachingDef.h line 18
namespace stringify { namespace ReachingDef {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}
 
namespace Rose {
    std::string stringifyReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyReachingDefType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/EditDistance/TreeEditDistance.h line 60
namespace stringify { namespace Rose { namespace EditDistance { namespace TreeEditDistance {
    const char* EditType(int64_t);
 
    std::string EditType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EditType();
}}}}
 
namespace Rose {
    std::string stringifyEditDistanceTreeEditDistanceEditType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyEditDistanceTreeEditDistanceEditType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 280
namespace stringify { namespace CollectAliasRelations {
    const char* COLOR(int64_t);
 
    std::string COLOR(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& COLOR();
}}
 
namespace Rose {
    std::string stringifyCollectAliasRelationsCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 281
namespace stringify { namespace CollectAliasRelations {
    const char* TRAVERSAL_TYPE(int64_t);
 
    std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TRAVERSAL_TYPE();
}}
 
namespace Rose {
    std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/PtrAliasAnalysis.h line 31
namespace stringify { namespace PtrAliasAnalysis {
    const char* COLOR(int64_t);
 
    std::string COLOR(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& COLOR();
}}
 
namespace Rose {
    std::string stringifyPtrAliasAnalysisCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPtrAliasAnalysisCOLOR();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/PtrAliasAnalysis.h line 33
namespace stringify { namespace PtrAliasAnalysis {
    const char* TRAVERSAL_TYPE(int64_t);
 
    std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TRAVERSAL_TYPE();
}}
 
namespace Rose {
    std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPtrAliasAnalysisTRAVERSAL_TYPE();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/matcherparser.h line 49
namespace stringify {
    const char* yytokentype(int64_t);
 
    std::string yytokentype(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& yytokentype();
}
 
namespace Rose {
    std::string stringify_yytokentype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_yytokentype();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 40
namespace stringify { namespace MatchStatus {
    const char* PatternMatchMode(int64_t);
 
    std::string PatternMatchMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PatternMatchMode();
}}
 
namespace Rose {
    std::string stringifyMatchStatusPatternMatchMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 41
namespace stringify { namespace MatchStatus {
    const char* CheckNodeMode(int64_t);
 
    std::string CheckNodeMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CheckNodeMode();
}}
 
namespace Rose {
    std::string stringifyMatchStatusCheckNodeMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astSnippet/Snippet.h line 319
namespace stringify { namespace Rose { namespace Snippet {
    const char* InsertMechanism(int64_t);
 
    std::string InsertMechanism(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InsertMechanism();
}}}
 
namespace Rose {
    std::string stringifySnippetInsertMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySnippetInsertMechanism();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astSnippet/Snippet.h line 329
namespace stringify { namespace Rose { namespace Snippet {
    const char* LocalDeclarationPosition(int64_t);
 
    std::string LocalDeclarationPosition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& LocalDeclarationPosition();
}}}
 
namespace Rose {
    std::string stringifySnippetLocalDeclarationPosition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/VariableIdMapping.h line 174
namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
    const char* AggregateType(int64_t);
 
    std::string AggregateType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AggregateType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornVariableIdMappingAggregateType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornVariableIdMappingAggregateType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/VariableIdMapping.h line 175
namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
    const char* VariableScope(int64_t);
 
    std::string VariableScope(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VariableScope();
}}}
 
namespace Rose {
    std::string stringifyCodeThornVariableIdMappingVariableScope(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornVariableIdMappingVariableScope();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/SgNodeHelper.h line 542
namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
    const char* OType(int64_t);
 
    std::string OType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OType();
}}}}
 
namespace Rose {
    std::string stringifySgNodeHelperPatternOutputTargetOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgNodeHelperPatternOutputTargetOType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 15
namespace stringify { namespace CodeThorn { namespace LabelProperty {
    const char* LabelType(int64_t);
 
    std::string LabelType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& LabelType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornLabelPropertyLabelType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyLabelType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 50
namespace stringify { namespace CodeThorn { namespace LabelProperty {
    const char* IOType(int64_t);
 
    std::string IOType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IOType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornLabelPropertyIOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyIOType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/booleanQuery.h line 43
namespace stringify { namespace BooleanQuery {
    const char* TypeOfQueryType(int64_t);
 
    std::string TypeOfQueryType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryType();
}}
 
namespace Rose {
    std::string stringifyBooleanQueryTypeOfQueryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 74
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);
 
    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}
 
namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 94
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);
 
    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}
 
namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/astQuery.h line 97
namespace stringify { namespace AstQueryNamespace {
    const char* QueryDepth(int64_t);
 
    std::string QueryDepth(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& QueryDepth();
}}
 
namespace Rose {
    std::string stringifyAstQueryNamespaceQueryDepth(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 10
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);
 
    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}
 
namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 19
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);
 
    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}
 
namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 133
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);
 
    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}
 
namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 154
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);
 
    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}
 
namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 17
namespace stringify {
    const char* Cxx_GrammarVariants(int64_t);
 
    std::string Cxx_GrammarVariants(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Cxx_GrammarVariants();
}
 
namespace Rose {
    std::string stringifyCxx_GrammarVariants(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCxx_GrammarVariants();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 703
namespace stringify {
    const char* VariantT(int64_t);
 
    std::string VariantT(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VariantT();
}
 
namespace Rose {
    std::string stringifyVariantT(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVariantT();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 9066
namespace stringify { namespace SgConstVolatileModifier {
    const char* cv_modifier_enum(int64_t);
 
    std::string cv_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cv_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgConstVolatileModifier_cv_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgConstVolatileModifier_cv_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 9571
namespace stringify { namespace SgStorageModifier {
    const char* storage_modifier_enum(int64_t);
 
    std::string storage_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& storage_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgStorageModifier_storage_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgStorageModifier_storage_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 10173
namespace stringify { namespace SgAccessModifier {
    const char* access_modifier_enum(int64_t);
 
    std::string access_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgAccessModifier_access_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAccessModifier_access_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 10676
namespace stringify { namespace SgFunctionModifier {
    const char* function_modifier_enum(int64_t);
 
    std::string function_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& function_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgFunctionModifier_function_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFunctionModifier_function_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 11415
namespace stringify { namespace SgUPC_AccessModifier {
    const char* upc_access_modifier_enum(int64_t);
 
    std::string upc_access_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upc_access_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgUPC_AccessModifier_upc_access_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUPC_AccessModifier_upc_access_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 11928
namespace stringify { namespace SgSpecialFunctionModifier {
    const char* special_function_modifier_enum(int64_t);
 
    std::string special_function_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& special_function_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgSpecialFunctionModifier_special_function_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgSpecialFunctionModifier_special_function_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 12446
namespace stringify { namespace SgElaboratedTypeModifier {
    const char* elaborated_type_modifier_enum(int64_t);
 
    std::string elaborated_type_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& elaborated_type_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgElaboratedTypeModifier_elaborated_type_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgElaboratedTypeModifier_elaborated_type_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 12949
namespace stringify { namespace SgLinkageModifier {
    const char* linkage_modifier_enum(int64_t);
 
    std::string linkage_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& linkage_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgLinkageModifier_linkage_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLinkageModifier_linkage_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 13443
namespace stringify { namespace SgBaseClassModifier {
    const char* baseclass_modifier_enum(int64_t);
 
    std::string baseclass_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& baseclass_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgBaseClassModifier_baseclass_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgBaseClassModifier_baseclass_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 13938
namespace stringify { namespace SgStructureModifier {
    const char* jovial_structure_modifier_enum(int64_t);
 
    std::string jovial_structure_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& jovial_structure_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgStructureModifier_jovial_structure_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgStructureModifier_jovial_structure_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 14440
namespace stringify { namespace SgTypeModifier {
    const char* type_modifier_enum(int64_t);
 
    std::string type_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& type_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgTypeModifier_type_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTypeModifier_type_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 14532
namespace stringify { namespace SgTypeModifier {
    const char* gnu_extension_machine_mode_enum(int64_t);
 
    std::string gnu_extension_machine_mode_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_machine_mode_enum();
}}
 
namespace Rose {
    std::string stringifySgTypeModifier_gnu_extension_machine_mode_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTypeModifier_gnu_extension_machine_mode_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 15319
namespace stringify { namespace SgDeclarationModifier {
    const char* declaration_modifier_enum(int64_t);
 
    std::string declaration_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& declaration_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationModifier_declaration_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationModifier_declaration_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 15363
namespace stringify { namespace SgDeclarationModifier {
    const char* gnu_declaration_visability_enum(int64_t);
 
    std::string gnu_declaration_visability_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_declaration_visability_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationModifier_gnu_declaration_visability_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationModifier_gnu_declaration_visability_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 16052
namespace stringify { namespace SgOpenclAccessModeModifier {
    const char* access_mode_modifier_enum(int64_t);
 
    std::string access_mode_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_mode_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOpenclAccessModeModifier_access_mode_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOpenclAccessModeModifier_access_mode_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 20434
namespace stringify { namespace Sg_File_Info {
    const char* classifier(int64_t);
 
    std::string classifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& classifier();
}}
 
namespace Rose {
    std::string stringifySg_File_Info_classifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySg_File_Info_classifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 20699
namespace stringify { namespace Sg_File_Info {
    const char* p_fileflags(int64_t);
 
    std::string p_fileflags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& p_fileflags();
}}
 
namespace Rose {
    std::string stringifySg_File_Info_p_fileflags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySg_File_Info_p_fileflags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 21260
namespace stringify { namespace SgFile {
    const char* outputFormatOption_enum(int64_t);
 
    std::string outputFormatOption_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& outputFormatOption_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_outputFormatOption_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_outputFormatOption_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 21275
namespace stringify { namespace SgFile {
    const char* languageOption_enum(int64_t);
 
    std::string languageOption_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& languageOption_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_languageOption_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_languageOption_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 21286
namespace stringify { namespace SgFile {
    const char* standard_enum(int64_t);
 
    std::string standard_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& standard_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_standard_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_standard_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 24290
namespace stringify { namespace SgProject {
    const char* template_instantiation_enum(int64_t);
 
    std::string template_instantiation_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_instantiation_enum();
}}
 
namespace Rose {
    std::string stringifySgProject_template_instantiation_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProject_template_instantiation_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 26182
namespace stringify { namespace SgUnparse_Info {
    const char* unparse_type_num(int64_t);
 
    std::string unparse_type_num(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& unparse_type_num();
}}
 
namespace Rose {
    std::string stringifySgUnparse_Info_unparse_type_num(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnparse_Info_unparse_type_num();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 26359
namespace stringify { namespace SgUnparse_Info {
    const char* access_attr_enum(int64_t);
 
    std::string access_attr_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_attr_enum();
}}
 
namespace Rose {
    std::string stringifySgUnparse_Info_access_attr_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnparse_Info_access_attr_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 29299
namespace stringify { namespace SgTemplateParameter {
    const char* template_parameter_enum(int64_t);
 
    std::string template_parameter_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_parameter_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateParameter_template_parameter_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateParameter_template_parameter_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 29835
namespace stringify { namespace SgTemplateArgument {
    const char* template_argument_enum(int64_t);
 
    std::string template_argument_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_argument_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateArgument_template_argument_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateArgument_template_argument_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 33813
namespace stringify { namespace SgGraph {
    const char* GraphEdgeType(int64_t);
 
    std::string GraphEdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GraphEdgeType();
}}
 
namespace Rose {
    std::string stringifySgGraphGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgGraphGraphEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 33827
namespace stringify { namespace SgGraph {
    const char* GraphProperties(int64_t);
 
    std::string GraphProperties(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GraphProperties();
}}
 
namespace Rose {
    std::string stringifySgGraphGraphProperties(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgGraphGraphProperties();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 43464
namespace stringify { namespace SgDataStatementValue {
    const char* data_statement_value_enum(int64_t);
 
    std::string data_statement_value_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& data_statement_value_enum();
}}
 
namespace Rose {
    std::string stringifySgDataStatementValue_data_statement_value_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDataStatementValue_data_statement_value_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 44555
namespace stringify { namespace SgType {
    const char* useWithinDeclarationEnum(int64_t);
 
    std::string useWithinDeclarationEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& useWithinDeclarationEnum();
}}
 
namespace Rose {
    std::string stringifySgType_useWithinDeclarationEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgType_useWithinDeclarationEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 44573
namespace stringify { namespace SgType {
    const char* fortran_attribute_specifiers_enum(int64_t);
 
    std::string fortran_attribute_specifiers_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& fortran_attribute_specifiers_enum();
}}
 
namespace Rose {
    std::string stringifySgType_fortran_attribute_specifiers_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgType_fortran_attribute_specifiers_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 61991
namespace stringify { namespace SgModifierType {
    const char* modifiers(int64_t);
 
    std::string modifiers(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& modifiers();
}}
 
namespace Rose {
    std::string stringifySgModifierType_modifiers(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgModifierType_modifiers();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 62045
namespace stringify { namespace SgModifierType {
    const char* type_modifier_enum(int64_t);
 
    std::string type_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& type_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgModifierType_type_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgModifierType_type_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 62062
namespace stringify { namespace SgModifierType {
    const char* storage_modifier_enum(int64_t);
 
    std::string storage_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& storage_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgModifierType_storage_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgModifierType_storage_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 62084
namespace stringify { namespace SgModifierType {
    const char* access_modifier_enum(int64_t);
 
    std::string access_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgModifierType_access_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgModifierType_access_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 63262
namespace stringify { namespace SgMemberFunctionType {
    const char* mfunc_specifier_enum(int64_t);
 
    std::string mfunc_specifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& mfunc_specifier_enum();
}}
 
namespace Rose {
    std::string stringifySgMemberFunctionType_mfunc_specifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgMemberFunctionType_mfunc_specifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 74907
namespace stringify { namespace SgLocatedNode {
    const char* PositionOfPreprocessingInfoInListType(int64_t);
 
    std::string PositionOfPreprocessingInfoInListType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PositionOfPreprocessingInfoInListType();
}}
 
namespace Rose {
    std::string stringifySgLocatedNodePositionOfPreprocessingInfoInListType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLocatedNodePositionOfPreprocessingInfoInListType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 75670
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Keywords(int64_t);
 
    std::string ROSE_Fortran_Keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Keywords();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 75837
namespace stringify { namespace SgToken {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 75906
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 75933
namespace stringify { namespace SgToken {
    const char* ROSE_C_CXX_Operators(int64_t);
 
    std::string ROSE_C_CXX_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_Operators();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_C_CXX_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_C_CXX_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 76013
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 77379
namespace stringify { namespace SgInitializedName {
    const char* preinitialization_enum(int64_t);
 
    std::string preinitialization_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& preinitialization_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_preinitialization_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_preinitialization_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 77394
namespace stringify { namespace SgInitializedName {
    const char* asm_register_name_enum(int64_t);
 
    std::string asm_register_name_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_register_name_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_asm_register_name_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_asm_register_name_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 77461
namespace stringify { namespace SgInitializedName {
    const char* gnu_variable_attribute_enum(int64_t);
 
    std::string gnu_variable_attribute_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_variable_attribute_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_gnu_variable_attribute_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_gnu_variable_attribute_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 77496
namespace stringify { namespace SgInitializedName {
    const char* excess_specifier_enum(int64_t);
 
    std::string excess_specifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& excess_specifier_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_excess_specifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_excess_specifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 79976
namespace stringify { namespace SgOmpClause {
    const char* omp_default_option_enum(int64_t);
 
    std::string omp_default_option_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_default_option_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_default_option_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_default_option_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 79989
namespace stringify { namespace SgOmpClause {
    const char* omp_schedule_kind_enum(int64_t);
 
    std::string omp_schedule_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_schedule_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_schedule_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_schedule_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 79998
namespace stringify { namespace SgOmpClause {
    const char* omp_schedule_modifier_enum(int64_t);
 
    std::string omp_schedule_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_schedule_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_schedule_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_schedule_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80005
namespace stringify { namespace SgOmpClause {
    const char* omp_in_reduction_identifier_enum(int64_t);
 
    std::string omp_in_reduction_identifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_in_reduction_identifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_in_reduction_identifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_in_reduction_identifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80032
namespace stringify { namespace SgOmpClause {
    const char* omp_task_reduction_identifier_enum(int64_t);
 
    std::string omp_task_reduction_identifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_task_reduction_identifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_task_reduction_identifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_task_reduction_identifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80059
namespace stringify { namespace SgOmpClause {
    const char* omp_defaultmap_behavior_enum(int64_t);
 
    std::string omp_defaultmap_behavior_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_defaultmap_behavior_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_defaultmap_behavior_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_defaultmap_behavior_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80071
namespace stringify { namespace SgOmpClause {
    const char* omp_defaultmap_category_enum(int64_t);
 
    std::string omp_defaultmap_category_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_defaultmap_category_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_defaultmap_category_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_defaultmap_category_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80080
namespace stringify { namespace SgOmpClause {
    const char* omp_reduction_identifier_enum(int64_t);
 
    std::string omp_reduction_identifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_reduction_identifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_reduction_identifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_reduction_identifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80110
namespace stringify { namespace SgOmpClause {
    const char* omp_reduction_modifier_enum(int64_t);
 
    std::string omp_reduction_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_reduction_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_reduction_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_reduction_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80118
namespace stringify { namespace SgOmpClause {
    const char* omp_linear_modifier_enum(int64_t);
 
    std::string omp_linear_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_linear_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_linear_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_linear_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80126
namespace stringify { namespace SgOmpClause {
    const char* omp_device_modifier_enum(int64_t);
 
    std::string omp_device_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_device_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_device_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_device_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80133
namespace stringify { namespace SgOmpClause {
    const char* omp_lastprivate_modifier_enum(int64_t);
 
    std::string omp_lastprivate_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_lastprivate_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_lastprivate_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_lastprivate_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80139
namespace stringify { namespace SgOmpClause {
    const char* omp_when_context_kind_enum(int64_t);
 
    std::string omp_when_context_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_when_context_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_when_context_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_when_context_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80150
namespace stringify { namespace SgOmpClause {
    const char* omp_when_context_vendor_enum(int64_t);
 
    std::string omp_when_context_vendor_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_when_context_vendor_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_when_context_vendor_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_when_context_vendor_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80167
namespace stringify { namespace SgOmpClause {
    const char* omp_allocate_modifier_enum(int64_t);
 
    std::string omp_allocate_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_allocate_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_allocate_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_allocate_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80183
namespace stringify { namespace SgOmpClause {
    const char* omp_allocator_modifier_enum(int64_t);
 
    std::string omp_allocator_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_allocator_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_allocator_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_allocator_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80199
namespace stringify { namespace SgOmpClause {
    const char* omp_uses_allocators_allocator_enum(int64_t);
 
    std::string omp_uses_allocators_allocator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_uses_allocators_allocator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_uses_allocators_allocator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_uses_allocators_allocator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80215
namespace stringify { namespace SgOmpClause {
    const char* omp_to_kind_enum(int64_t);
 
    std::string omp_to_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_to_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_to_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_to_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80221
namespace stringify { namespace SgOmpClause {
    const char* omp_from_kind_enum(int64_t);
 
    std::string omp_from_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_from_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_from_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_from_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80227
namespace stringify { namespace SgOmpClause {
    const char* omp_dependence_type_enum(int64_t);
 
    std::string omp_dependence_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_dependence_type_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_dependence_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_dependence_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80239
namespace stringify { namespace SgOmpClause {
    const char* omp_depend_modifier_enum(int64_t);
 
    std::string omp_depend_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_depend_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_depend_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_depend_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80245
namespace stringify { namespace SgOmpClause {
    const char* omp_affinity_modifier_enum(int64_t);
 
    std::string omp_affinity_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_affinity_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_affinity_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_affinity_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80251
namespace stringify { namespace SgOmpClause {
    const char* upir_target_type_enum(int64_t);
 
    std::string upir_target_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_target_type_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_target_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_target_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80259
namespace stringify { namespace SgOmpClause {
    const char* upir_data_sharing_enum(int64_t);
 
    std::string upir_data_sharing_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_sharing_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_sharing_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_sharing_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80269
namespace stringify { namespace SgOmpClause {
    const char* upir_data_mapping_enum(int64_t);
 
    std::string upir_data_mapping_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_mapping_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_mapping_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_mapping_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80279
namespace stringify { namespace SgOmpClause {
    const char* upir_property_visibility_enum(int64_t);
 
    std::string upir_property_visibility_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_property_visibility_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_property_visibility_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_property_visibility_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80286
namespace stringify { namespace SgOmpClause {
    const char* upir_data_access_enum(int64_t);
 
    std::string upir_data_access_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_access_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_access_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_access_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80294
namespace stringify { namespace SgOmpClause {
    const char* upir_data_distribution_pattern_enum(int64_t);
 
    std::string upir_data_distribution_pattern_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_distribution_pattern_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_distribution_pattern_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_distribution_pattern_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80303
namespace stringify { namespace SgOmpClause {
    const char* upir_data_allocator_enum(int64_t);
 
    std::string upir_data_allocator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_allocator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_allocator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_allocator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80310
namespace stringify { namespace SgOmpClause {
    const char* upir_data_deallocator_enum(int64_t);
 
    std::string upir_data_deallocator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upir_data_deallocator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_upir_data_deallocator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_upir_data_deallocator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80318
namespace stringify { namespace SgOmpClause {
    const char* omp_map_operator_enum(int64_t);
 
    std::string omp_map_operator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_map_operator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_map_operator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_map_operator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80329
namespace stringify { namespace SgOmpClause {
    const char* omp_map_dist_data_enum(int64_t);
 
    std::string omp_map_dist_data_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_map_dist_data_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_map_dist_data_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_map_dist_data_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80339
namespace stringify { namespace SgOmpClause {
    const char* omp_proc_bind_policy_enum(int64_t);
 
    std::string omp_proc_bind_policy_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_proc_bind_policy_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_proc_bind_policy_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_proc_bind_policy_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80348
namespace stringify { namespace SgOmpClause {
    const char* omp_bind_binding_enum(int64_t);
 
    std::string omp_bind_binding_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_bind_binding_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_bind_binding_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_bind_binding_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80356
namespace stringify { namespace SgOmpClause {
    const char* omp_atomic_default_mem_order_kind_enum(int64_t);
 
    std::string omp_atomic_default_mem_order_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_atomic_default_mem_order_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_atomic_default_mem_order_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_atomic_default_mem_order_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80364
namespace stringify { namespace SgOmpClause {
    const char* omp_order_kind_enum(int64_t);
 
    std::string omp_order_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_order_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_order_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_order_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80370
namespace stringify { namespace SgOmpClause {
    const char* omp_dist_schedule_kind_enum(int64_t);
 
    std::string omp_dist_schedule_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_dist_schedule_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_dist_schedule_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_dist_schedule_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80376
namespace stringify { namespace SgOmpClause {
    const char* omp_atomic_clause_enum(int64_t);
 
    std::string omp_atomic_clause_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_atomic_clause_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_atomic_clause_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_atomic_clause_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80385
namespace stringify { namespace SgOmpClause {
    const char* omp_if_modifier_enum(int64_t);
 
    std::string omp_if_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_if_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_if_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_if_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 80400
namespace stringify { namespace SgOmpClause {
    const char* omp_depobj_modifier_enum(int64_t);
 
    std::string omp_depobj_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_depobj_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_depobj_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_depobj_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 134181
namespace stringify { namespace SgForAllStatement {
    const char* forall_statement_kind_enum(int64_t);
 
    std::string forall_statement_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& forall_statement_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgForAllStatement_forall_statement_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgForAllStatement_forall_statement_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 137634
namespace stringify { namespace SgDeclarationStatement {
    const char* template_specialization_enum(int64_t);
 
    std::string template_specialization_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_specialization_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationStatement_template_specialization_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationStatement_template_specialization_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 137649
namespace stringify { namespace SgDeclarationStatement {
    const char* gnu_extension_visability_attribute_enum(int64_t);
 
    std::string gnu_extension_visability_attribute_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_visability_attribute_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationStatement_gnu_extension_visability_attribute_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationStatement_gnu_extension_visability_attribute_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 139062
namespace stringify { namespace SgVariableDeclaration {
    const char* gnu_extension_declaration_attributes_enum(int64_t);
 
    std::string gnu_extension_declaration_attributes_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_declaration_attributes_enum();
}}
 
namespace Rose {
    std::string stringifySgVariableDeclaration_gnu_extension_declaration_attributes_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgVariableDeclaration_gnu_extension_declaration_attributes_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 143297
namespace stringify { namespace SgAttributeSpecificationStatement {
    const char* attribute_spec_enum(int64_t);
 
    std::string attribute_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& attribute_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgAttributeSpecificationStatement_attribute_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAttributeSpecificationStatement_attribute_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 144299
namespace stringify { namespace SgTemplateDeclaration {
    const char* template_type_enum(int64_t);
 
    std::string template_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_type_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateDeclaration_template_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateDeclaration_template_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 147213
namespace stringify { namespace SgInterfaceStatement {
    const char* generic_spec_enum(int64_t);
 
    std::string generic_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& generic_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgInterfaceStatement_generic_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInterfaceStatement_generic_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 152217
namespace stringify { namespace SgClassDeclaration {
    const char* class_types(int64_t);
 
    std::string class_types(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& class_types();
}}
 
namespace Rose {
    std::string stringifySgClassDeclaration_class_types(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgClassDeclaration_class_types();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 152905
namespace stringify { namespace SgTemplateClassDeclaration {
    const char* class_types(int64_t);
 
    std::string class_types(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& class_types();
}}
 
namespace Rose {
    std::string stringifySgTemplateClassDeclaration_class_types(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateClassDeclaration_class_types();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 154850
namespace stringify { namespace SgImplicitStatement {
    const char* implicit_spec_enum(int64_t);
 
    std::string implicit_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& implicit_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgImplicitStatement_implicit_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgImplicitStatement_implicit_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 160689
namespace stringify { namespace SgProcedureHeaderStatement {
    const char* subprogram_kind_enum(int64_t);
 
    std::string subprogram_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& subprogram_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgProcedureHeaderStatement_subprogram_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProcedureHeaderStatement_subprogram_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 181390
namespace stringify { namespace SgProcessControlStatement {
    const char* control_enum(int64_t);
 
    std::string control_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& control_enum();
}}
 
namespace Rose {
    std::string stringifySgProcessControlStatement_control_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProcessControlStatement_control_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 181880
namespace stringify { namespace SgIOStatement {
    const char* io_statement_enum(int64_t);
 
    std::string io_statement_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& io_statement_enum();
}}
 
namespace Rose {
    std::string stringifySgIOStatement_io_statement_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgIOStatement_io_statement_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 227031
namespace stringify { namespace SgImageControlStatement {
    const char* image_control_statement_enum(int64_t);
 
    std::string image_control_statement_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& image_control_statement_enum();
}}
 
namespace Rose {
    std::string stringifySgImageControlStatement_image_control_statement_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgImageControlStatement_image_control_statement_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 230892
namespace stringify { namespace SgUnaryOp {
    const char* Sgop_mode(int64_t);
 
    std::string Sgop_mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Sgop_mode();
}}
 
namespace Rose {
    std::string stringifySgUnaryOpSgop_mode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnaryOpSgop_mode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 235461
namespace stringify { namespace SgCastExp {
    const char* cast_type_enum(int64_t);
 
    std::string cast_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cast_type_enum();
}}
 
namespace Rose {
    std::string stringifySgCastExp_cast_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgCastExp_cast_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 236040
namespace stringify { namespace SgThrowOp {
    const char* e_throw_kind(int64_t);
 
    std::string e_throw_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& e_throw_kind();
}}
 
namespace Rose {
    std::string stringifySgThrowOp_e_throw_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgThrowOp_e_throw_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 305735
namespace stringify { namespace SgAsmOp {
    const char* asm_operand_modifier_enum(int64_t);
 
    std::string asm_operand_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_operand_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgAsmOp_asm_operand_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmOp_asm_operand_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 305754
namespace stringify { namespace SgAsmOp {
    const char* asm_operand_constraint_enum(int64_t);
 
    std::string asm_operand_constraint_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_operand_constraint_enum();
}}
 
namespace Rose {
    std::string stringifySgAsmOp_asm_operand_constraint_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmOp_asm_operand_constraint_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_Grammar.h line 330291
namespace stringify { namespace SgLabelSymbol {
    const char* label_type_enum(int64_t);
 
    std::string label_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& label_type_enum();
}}
 
namespace Rose {
    std::string stringifySgLabelSymbol_label_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLabelSymbol_label_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 3
namespace stringify {
    const char* E_SgSourceFile(int64_t);
 
    std::string E_SgSourceFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSourceFile();
}
 
namespace Rose {
    std::string stringifyE_SgSourceFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSourceFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 6
namespace stringify {
    const char* E_SgUnknownFile(int64_t);
 
    std::string E_SgUnknownFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnknownFile();
}
 
namespace Rose {
    std::string stringifyE_SgUnknownFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnknownFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 9
namespace stringify {
    const char* E_SgProject(int64_t);
 
    std::string E_SgProject(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProject();
}
 
namespace Rose {
    std::string stringifyE_SgProject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 12
namespace stringify {
    const char* E_SgExpBaseClass(int64_t);
 
    std::string E_SgExpBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExpBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgExpBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExpBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 15
namespace stringify {
    const char* E_SgNonrealBaseClass(int64_t);
 
    std::string E_SgNonrealBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 18
namespace stringify {
    const char* E_SgBaseClass(int64_t);
 
    std::string E_SgBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 21
namespace stringify {
    const char* E_SgTemplateParameter(int64_t);
 
    std::string E_SgTemplateParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateParameter();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 24
namespace stringify {
    const char* E_SgTemplateArgument(int64_t);
 
    std::string E_SgTemplateArgument(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateArgument();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateArgument(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateArgument();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 27
namespace stringify {
    const char* E_SgDirectory(int64_t);
 
    std::string E_SgDirectory(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDirectory();
}
 
namespace Rose {
    std::string stringifyE_SgDirectory(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDirectory();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 30
namespace stringify {
    const char* E_SgFileList(int64_t);
 
    std::string E_SgFileList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFileList();
}
 
namespace Rose {
    std::string stringifyE_SgFileList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFileList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 33
namespace stringify {
    const char* E_SgDirectoryList(int64_t);
 
    std::string E_SgDirectoryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDirectoryList();
}
 
namespace Rose {
    std::string stringifyE_SgDirectoryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDirectoryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 36
namespace stringify {
    const char* E_SgTemplateArgumentList(int64_t);
 
    std::string E_SgTemplateArgumentList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateArgumentList();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateArgumentList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateArgumentList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 39
namespace stringify {
    const char* E_SgTemplateParameterList(int64_t);
 
    std::string E_SgTemplateParameterList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateParameterList();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateParameterList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateParameterList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 42
namespace stringify {
    const char* E_SgIncludeFile(int64_t);
 
    std::string E_SgIncludeFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIncludeFile();
}
 
namespace Rose {
    std::string stringifyE_SgIncludeFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIncludeFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 45
namespace stringify {
    const char* E_SgTypeUnknown(int64_t);
 
    std::string E_SgTypeUnknown(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnknown();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnknown(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnknown();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 48
namespace stringify {
    const char* E_SgTypeChar(int64_t);
 
    std::string E_SgTypeChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 51
namespace stringify {
    const char* E_SgTypeSignedChar(int64_t);
 
    std::string E_SgTypeSignedChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 54
namespace stringify {
    const char* E_SgTypeUnsignedChar(int64_t);
 
    std::string E_SgTypeUnsignedChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 57
namespace stringify {
    const char* E_SgTypeShort(int64_t);
 
    std::string E_SgTypeShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 60
namespace stringify {
    const char* E_SgTypeSignedShort(int64_t);
 
    std::string E_SgTypeSignedShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 63
namespace stringify {
    const char* E_SgTypeUnsignedShort(int64_t);
 
    std::string E_SgTypeUnsignedShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 66
namespace stringify {
    const char* E_SgTypeInt(int64_t);
 
    std::string E_SgTypeInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 69
namespace stringify {
    const char* E_SgTypeSignedInt(int64_t);
 
    std::string E_SgTypeSignedInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 72
namespace stringify {
    const char* E_SgTypeUnsignedInt(int64_t);
 
    std::string E_SgTypeUnsignedInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 75
namespace stringify {
    const char* E_SgTypeLong(int64_t);
 
    std::string E_SgTypeLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 78
namespace stringify {
    const char* E_SgTypeSignedLong(int64_t);
 
    std::string E_SgTypeSignedLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 81
namespace stringify {
    const char* E_SgTypeUnsignedLong(int64_t);
 
    std::string E_SgTypeUnsignedLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 84
namespace stringify {
    const char* E_SgTypeVoid(int64_t);
 
    std::string E_SgTypeVoid(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeVoid();
}
 
namespace Rose {
    std::string stringifyE_SgTypeVoid(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeVoid();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 87
namespace stringify {
    const char* E_SgTypeGlobalVoid(int64_t);
 
    std::string E_SgTypeGlobalVoid(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeGlobalVoid();
}
 
namespace Rose {
    std::string stringifyE_SgTypeGlobalVoid(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeGlobalVoid();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 90
namespace stringify {
    const char* E_SgTypeWchar(int64_t);
 
    std::string E_SgTypeWchar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeWchar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeWchar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeWchar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 93
namespace stringify {
    const char* E_SgTypeFloat(int64_t);
 
    std::string E_SgTypeFloat(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 96
namespace stringify {
    const char* E_SgTypeDouble(int64_t);
 
    std::string E_SgTypeDouble(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeDouble();
}
 
namespace Rose {
    std::string stringifyE_SgTypeDouble(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeDouble();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 99
namespace stringify {
    const char* E_SgTypeLongLong(int64_t);
 
    std::string E_SgTypeLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 102
namespace stringify {
    const char* E_SgTypeSignedLongLong(int64_t);
 
    std::string E_SgTypeSignedLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 105
namespace stringify {
    const char* E_SgTypeUnsignedLongLong(int64_t);
 
    std::string E_SgTypeUnsignedLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 108
namespace stringify {
    const char* E_SgTypeSigned128bitInteger(int64_t);
 
    std::string E_SgTypeSigned128bitInteger(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSigned128bitInteger();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSigned128bitInteger(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSigned128bitInteger();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 111
namespace stringify {
    const char* E_SgTypeUnsigned128bitInteger(int64_t);
 
    std::string E_SgTypeUnsigned128bitInteger(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsigned128bitInteger();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsigned128bitInteger(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsigned128bitInteger();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 114
namespace stringify {
    const char* E_SgTypeFloat80(int64_t);
 
    std::string E_SgTypeFloat80(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat80();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat80(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat80();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 117
namespace stringify {
    const char* E_SgTypeLongDouble(int64_t);
 
    std::string E_SgTypeLongDouble(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLongDouble();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLongDouble(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLongDouble();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 120
namespace stringify {
    const char* E_SgTypeString(int64_t);
 
    std::string E_SgTypeString(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeString();
}
 
namespace Rose {
    std::string stringifyE_SgTypeString(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeString();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 123
namespace stringify {
    const char* E_SgTypeBool(int64_t);
 
    std::string E_SgTypeBool(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeBool();
}
 
namespace Rose {
    std::string stringifyE_SgTypeBool(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeBool();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 126
namespace stringify {
    const char* E_SgPointerMemberType(int64_t);
 
    std::string E_SgPointerMemberType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerMemberType();
}
 
namespace Rose {
    std::string stringifyE_SgPointerMemberType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerMemberType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 129
namespace stringify {
    const char* E_SgPointerType(int64_t);
 
    std::string E_SgPointerType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerType();
}
 
namespace Rose {
    std::string stringifyE_SgPointerType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 132
namespace stringify {
    const char* E_SgReferenceType(int64_t);
 
    std::string E_SgReferenceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReferenceType();
}
 
namespace Rose {
    std::string stringifyE_SgReferenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReferenceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 135
namespace stringify {
    const char* E_SgClassType(int64_t);
 
    std::string E_SgClassType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassType();
}
 
namespace Rose {
    std::string stringifyE_SgClassType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 138
namespace stringify {
    const char* E_SgEnumType(int64_t);
 
    std::string E_SgEnumType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumType();
}
 
namespace Rose {
    std::string stringifyE_SgEnumType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 141
namespace stringify {
    const char* E_SgTypedefType(int64_t);
 
    std::string E_SgTypedefType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefType();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 144
namespace stringify {
    const char* E_SgNonrealType(int64_t);
 
    std::string E_SgNonrealType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealType();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 147
namespace stringify {
    const char* E_SgNamedType(int64_t);
 
    std::string E_SgNamedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamedType();
}
 
namespace Rose {
    std::string stringifyE_SgNamedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 150
namespace stringify {
    const char* E_SgModifierType(int64_t);
 
    std::string E_SgModifierType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModifierType();
}
 
namespace Rose {
    std::string stringifyE_SgModifierType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModifierType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 153
namespace stringify {
    const char* E_SgPartialFunctionModifierType(int64_t);
 
    std::string E_SgPartialFunctionModifierType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPartialFunctionModifierType();
}
 
namespace Rose {
    std::string stringifyE_SgPartialFunctionModifierType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPartialFunctionModifierType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 156
namespace stringify {
    const char* E_SgPartialFunctionType(int64_t);
 
    std::string E_SgPartialFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPartialFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgPartialFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPartialFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 159
namespace stringify {
    const char* E_SgMemberFunctionType(int64_t);
 
    std::string E_SgMemberFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 162
namespace stringify {
    const char* E_SgFunctionType(int64_t);
 
    std::string E_SgFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 165
namespace stringify {
    const char* E_SgArrayType(int64_t);
 
    std::string E_SgArrayType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrayType();
}
 
namespace Rose {
    std::string stringifyE_SgArrayType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrayType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 168
namespace stringify {
    const char* E_SgTypeEllipse(int64_t);
 
    std::string E_SgTypeEllipse(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeEllipse();
}
 
namespace Rose {
    std::string stringifyE_SgTypeEllipse(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeEllipse();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 171
namespace stringify {
    const char* E_SgTemplateType(int64_t);
 
    std::string E_SgTemplateType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateType();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 174
namespace stringify {
    const char* E_SgQualifiedNameType(int64_t);
 
    std::string E_SgQualifiedNameType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgQualifiedNameType();
}
 
namespace Rose {
    std::string stringifyE_SgQualifiedNameType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgQualifiedNameType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 177
namespace stringify {
    const char* E_SgTypeComplex(int64_t);
 
    std::string E_SgTypeComplex(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeComplex();
}
 
namespace Rose {
    std::string stringifyE_SgTypeComplex(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeComplex();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 180
namespace stringify {
    const char* E_SgTypeImaginary(int64_t);
 
    std::string E_SgTypeImaginary(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeImaginary();
}
 
namespace Rose {
    std::string stringifyE_SgTypeImaginary(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeImaginary();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 183
namespace stringify {
    const char* E_SgTypeDefault(int64_t);
 
    std::string E_SgTypeDefault(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeDefault();
}
 
namespace Rose {
    std::string stringifyE_SgTypeDefault(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeDefault();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 186
namespace stringify {
    const char* E_SgTypeCAFTeam(int64_t);
 
    std::string E_SgTypeCAFTeam(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeCAFTeam();
}
 
namespace Rose {
    std::string stringifyE_SgTypeCAFTeam(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeCAFTeam();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 189
namespace stringify {
    const char* E_SgTypeCrayPointer(int64_t);
 
    std::string E_SgTypeCrayPointer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeCrayPointer();
}
 
namespace Rose {
    std::string stringifyE_SgTypeCrayPointer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeCrayPointer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 192
namespace stringify {
    const char* E_SgTypeLabel(int64_t);
 
    std::string E_SgTypeLabel(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLabel();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLabel(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLabel();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 195
namespace stringify {
    const char* E_SgRvalueReferenceType(int64_t);
 
    std::string E_SgRvalueReferenceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRvalueReferenceType();
}
 
namespace Rose {
    std::string stringifyE_SgRvalueReferenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRvalueReferenceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 198
namespace stringify {
    const char* E_SgTypeNullptr(int64_t);
 
    std::string E_SgTypeNullptr(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeNullptr();
}
 
namespace Rose {
    std::string stringifyE_SgTypeNullptr(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeNullptr();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 201
namespace stringify {
    const char* E_SgDeclType(int64_t);
 
    std::string E_SgDeclType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeclType();
}
 
namespace Rose {
    std::string stringifyE_SgDeclType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeclType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 204
namespace stringify {
    const char* E_SgTypeOfType(int64_t);
 
    std::string E_SgTypeOfType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeOfType();
}
 
namespace Rose {
    std::string stringifyE_SgTypeOfType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeOfType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 207
namespace stringify {
    const char* E_SgTypeMatrix(int64_t);
 
    std::string E_SgTypeMatrix(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeMatrix();
}
 
namespace Rose {
    std::string stringifyE_SgTypeMatrix(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeMatrix();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 210
namespace stringify {
    const char* E_SgTypeTuple(int64_t);
 
    std::string E_SgTypeTuple(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeTuple();
}
 
namespace Rose {
    std::string stringifyE_SgTypeTuple(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeTuple();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 213
namespace stringify {
    const char* E_SgTypeChar16(int64_t);
 
    std::string E_SgTypeChar16(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar16();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar16(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar16();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 216
namespace stringify {
    const char* E_SgTypeChar32(int64_t);
 
    std::string E_SgTypeChar32(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar32();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar32(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar32();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 219
namespace stringify {
    const char* E_SgTypeFloat128(int64_t);
 
    std::string E_SgTypeFloat128(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat128();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat128(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat128();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 222
namespace stringify {
    const char* E_SgTypeFixed(int64_t);
 
    std::string E_SgTypeFixed(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFixed();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFixed(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFixed();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 225
namespace stringify {
    const char* E_SgAutoType(int64_t);
 
    std::string E_SgAutoType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAutoType();
}
 
namespace Rose {
    std::string stringifyE_SgAutoType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAutoType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 228
namespace stringify {
    const char* E_SgType(int64_t);
 
    std::string E_SgType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgType();
}
 
namespace Rose {
    std::string stringifyE_SgType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 231
namespace stringify {
    const char* E_SgCommonBlockObject(int64_t);
 
    std::string E_SgCommonBlockObject(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommonBlockObject();
}
 
namespace Rose {
    std::string stringifyE_SgCommonBlockObject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommonBlockObject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 234
namespace stringify {
    const char* E_SgInitializedName(int64_t);
 
    std::string E_SgInitializedName(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInitializedName();
}
 
namespace Rose {
    std::string stringifyE_SgInitializedName(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInitializedName();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 237
namespace stringify {
    const char* E_SgOmpDefaultClause(int64_t);
 
    std::string E_SgOmpDefaultClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDefaultClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDefaultClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDefaultClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 240
namespace stringify {
    const char* E_SgOmpDistScheduleClause(int64_t);
 
    std::string E_SgOmpDistScheduleClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDistScheduleClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDistScheduleClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDistScheduleClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 243
namespace stringify {
    const char* E_SgOmpOrderedClause(int64_t);
 
    std::string E_SgOmpOrderedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpOrderedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpOrderedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpOrderedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 246
namespace stringify {
    const char* E_SgOmpCollapseClause(int64_t);
 
    std::string E_SgOmpCollapseClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCollapseClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCollapseClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCollapseClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 249
namespace stringify {
    const char* E_SgOmpIfClause(int64_t);
 
    std::string E_SgOmpIfClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpIfClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpIfClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpIfClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 252
namespace stringify {
    const char* E_SgUpirNumUnitsField(int64_t);
 
    std::string E_SgUpirNumUnitsField(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirNumUnitsField();
}
 
namespace Rose {
    std::string stringifyE_SgUpirNumUnitsField(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirNumUnitsField();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 255
namespace stringify {
    const char* E_SgOmpNumTeamsClause(int64_t);
 
    std::string E_SgOmpNumTeamsClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpNumTeamsClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpNumTeamsClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpNumTeamsClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 258
namespace stringify {
    const char* E_SgOmpThreadLimitClause(int64_t);
 
    std::string E_SgOmpThreadLimitClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpThreadLimitClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpThreadLimitClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpThreadLimitClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 261
namespace stringify {
    const char* E_SgOmpDeviceClause(int64_t);
 
    std::string E_SgOmpDeviceClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDeviceClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDeviceClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDeviceClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 264
namespace stringify {
    const char* E_SgOmpHintClause(int64_t);
 
    std::string E_SgOmpHintClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpHintClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpHintClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpHintClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 267
namespace stringify {
    const char* E_SgOmpGrainsizeClause(int64_t);
 
    std::string E_SgOmpGrainsizeClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpGrainsizeClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpGrainsizeClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpGrainsizeClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 270
namespace stringify {
    const char* E_SgOmpNumTasksClause(int64_t);
 
    std::string E_SgOmpNumTasksClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpNumTasksClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpNumTasksClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpNumTasksClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 273
namespace stringify {
    const char* E_SgOmpDetachClause(int64_t);
 
    std::string E_SgOmpDetachClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDetachClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDetachClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDetachClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 276
namespace stringify {
    const char* E_SgOmpSafelenClause(int64_t);
 
    std::string E_SgOmpSafelenClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSafelenClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSafelenClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSafelenClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 279
namespace stringify {
    const char* E_SgOmpSimdlenClause(int64_t);
 
    std::string E_SgOmpSimdlenClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSimdlenClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSimdlenClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSimdlenClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 282
namespace stringify {
    const char* E_SgOmpFinalClause(int64_t);
 
    std::string E_SgOmpFinalClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFinalClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFinalClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFinalClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 285
namespace stringify {
    const char* E_SgOmpPriorityClause(int64_t);
 
    std::string E_SgOmpPriorityClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpPriorityClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpPriorityClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpPriorityClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 288
namespace stringify {
    const char* E_SgOmpPartialClause(int64_t);
 
    std::string E_SgOmpPartialClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpPartialClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpPartialClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpPartialClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 291
namespace stringify {
    const char* E_SgOmpSizesClause(int64_t);
 
    std::string E_SgOmpSizesClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSizesClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSizesClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSizesClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 294
namespace stringify {
    const char* E_SgOmpExpressionClause(int64_t);
 
    std::string E_SgOmpExpressionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpExpressionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpExpressionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpExpressionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 297
namespace stringify {
    const char* E_SgOmpExtImplementationDefinedRequirementClause(int64_t);
 
    std::string E_SgOmpExtImplementationDefinedRequirementClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpExtImplementationDefinedRequirementClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpExtImplementationDefinedRequirementClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpExtImplementationDefinedRequirementClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 300
namespace stringify {
    const char* E_SgOmpCopyprivateClause(int64_t);
 
    std::string E_SgOmpCopyprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCopyprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCopyprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCopyprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 303
namespace stringify {
    const char* E_SgOmpPrivateClause(int64_t);
 
    std::string E_SgOmpPrivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpPrivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpPrivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpPrivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 306
namespace stringify {
    const char* E_SgOmpFirstprivateClause(int64_t);
 
    std::string E_SgOmpFirstprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFirstprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFirstprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFirstprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 309
namespace stringify {
    const char* E_SgOmpNontemporalClause(int64_t);
 
    std::string E_SgOmpNontemporalClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpNontemporalClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpNontemporalClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpNontemporalClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 312
namespace stringify {
    const char* E_SgOmpInclusiveClause(int64_t);
 
    std::string E_SgOmpInclusiveClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpInclusiveClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpInclusiveClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpInclusiveClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 315
namespace stringify {
    const char* E_SgOmpExclusiveClause(int64_t);
 
    std::string E_SgOmpExclusiveClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpExclusiveClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpExclusiveClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpExclusiveClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 318
namespace stringify {
    const char* E_SgOmpIsDevicePtrClause(int64_t);
 
    std::string E_SgOmpIsDevicePtrClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpIsDevicePtrClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpIsDevicePtrClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpIsDevicePtrClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 321
namespace stringify {
    const char* E_SgOmpUseDevicePtrClause(int64_t);
 
    std::string E_SgOmpUseDevicePtrClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpUseDevicePtrClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpUseDevicePtrClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpUseDevicePtrClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 324
namespace stringify {
    const char* E_SgOmpUseDeviceAddrClause(int64_t);
 
    std::string E_SgOmpUseDeviceAddrClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpUseDeviceAddrClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpUseDeviceAddrClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpUseDeviceAddrClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 327
namespace stringify {
    const char* E_SgOmpSharedClause(int64_t);
 
    std::string E_SgOmpSharedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSharedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSharedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSharedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 330
namespace stringify {
    const char* E_SgOmpCopyinClause(int64_t);
 
    std::string E_SgOmpCopyinClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCopyinClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCopyinClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCopyinClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 333
namespace stringify {
    const char* E_SgOmpLastprivateClause(int64_t);
 
    std::string E_SgOmpLastprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpLastprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpLastprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpLastprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 336
namespace stringify {
    const char* E_SgOmpReductionClause(int64_t);
 
    std::string E_SgOmpReductionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpReductionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpReductionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpReductionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 339
namespace stringify {
    const char* E_SgOmpInReductionClause(int64_t);
 
    std::string E_SgOmpInReductionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpInReductionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpInReductionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpInReductionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 342
namespace stringify {
    const char* E_SgOmpTaskReductionClause(int64_t);
 
    std::string E_SgOmpTaskReductionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskReductionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskReductionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskReductionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 345
namespace stringify {
    const char* E_SgOmpMapClause(int64_t);
 
    std::string E_SgOmpMapClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMapClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMapClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMapClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 348
namespace stringify {
    const char* E_SgOmpAllocateClause(int64_t);
 
    std::string E_SgOmpAllocateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAllocateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAllocateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAllocateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 351
namespace stringify {
    const char* E_SgOmpUniformClause(int64_t);
 
    std::string E_SgOmpUniformClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpUniformClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpUniformClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpUniformClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 354
namespace stringify {
    const char* E_SgOmpAlignedClause(int64_t);
 
    std::string E_SgOmpAlignedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAlignedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAlignedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAlignedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 357
namespace stringify {
    const char* E_SgOmpLinearClause(int64_t);
 
    std::string E_SgOmpLinearClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpLinearClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpLinearClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpLinearClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 360
namespace stringify {
    const char* E_SgOmpDependClause(int64_t);
 
    std::string E_SgOmpDependClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDependClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDependClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDependClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 363
namespace stringify {
    const char* E_SgOmpAffinityClause(int64_t);
 
    std::string E_SgOmpAffinityClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAffinityClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAffinityClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAffinityClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 366
namespace stringify {
    const char* E_SgOmpToClause(int64_t);
 
    std::string E_SgOmpToClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpToClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpToClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpToClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 369
namespace stringify {
    const char* E_SgOmpFromClause(int64_t);
 
    std::string E_SgOmpFromClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFromClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFromClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFromClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 372
namespace stringify {
    const char* E_SgOmpVariablesClause(int64_t);
 
    std::string E_SgOmpVariablesClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpVariablesClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpVariablesClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpVariablesClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 375
namespace stringify {
    const char* E_SgOmpScheduleClause(int64_t);
 
    std::string E_SgOmpScheduleClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpScheduleClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpScheduleClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpScheduleClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 378
namespace stringify {
    const char* E_SgOmpWhenClause(int64_t);
 
    std::string E_SgOmpWhenClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpWhenClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpWhenClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpWhenClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 381
namespace stringify {
    const char* E_SgUpirDataItemField(int64_t);
 
    std::string E_SgUpirDataItemField(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirDataItemField();
}
 
namespace Rose {
    std::string stringifyE_SgUpirDataItemField(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirDataItemField();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 384
namespace stringify {
    const char* E_SgLambdaCapture(int64_t);
 
    std::string E_SgLambdaCapture(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaCapture();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaCapture(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaCapture();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 387
namespace stringify {
    const char* E_SgLambdaCaptureList(int64_t);
 
    std::string E_SgLambdaCaptureList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaCaptureList();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaCaptureList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaCaptureList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 390
namespace stringify {
    const char* E_SgGlobal(int64_t);
 
    std::string E_SgGlobal(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGlobal();
}
 
namespace Rose {
    std::string stringifyE_SgGlobal(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGlobal();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 393
namespace stringify {
    const char* E_SgBasicBlock(int64_t);
 
    std::string E_SgBasicBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBasicBlock();
}
 
namespace Rose {
    std::string stringifyE_SgBasicBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBasicBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 396
namespace stringify {
    const char* E_SgIfStmt(int64_t);
 
    std::string E_SgIfStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIfStmt();
}
 
namespace Rose {
    std::string stringifyE_SgIfStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIfStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 399
namespace stringify {
    const char* E_SgForStatement(int64_t);
 
    std::string E_SgForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 402
namespace stringify {
    const char* E_SgTemplateFunctionDefinition(int64_t);
 
    std::string E_SgTemplateFunctionDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 405
namespace stringify {
    const char* E_SgFunctionDefinition(int64_t);
 
    std::string E_SgFunctionDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 408
namespace stringify {
    const char* E_SgTemplateInstantiationDefn(int64_t);
 
    std::string E_SgTemplateInstantiationDefn(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDefn();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDefn(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDefn();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 411
namespace stringify {
    const char* E_SgTemplateClassDefinition(int64_t);
 
    std::string E_SgTemplateClassDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 414
namespace stringify {
    const char* E_SgClassDefinition(int64_t);
 
    std::string E_SgClassDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgClassDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 417
namespace stringify {
    const char* E_SgWhileStmt(int64_t);
 
    std::string E_SgWhileStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWhileStmt();
}
 
namespace Rose {
    std::string stringifyE_SgWhileStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWhileStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 420
namespace stringify {
    const char* E_SgDoWhileStmt(int64_t);
 
    std::string E_SgDoWhileStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDoWhileStmt();
}
 
namespace Rose {
    std::string stringifyE_SgDoWhileStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDoWhileStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 423
namespace stringify {
    const char* E_SgSwitchStatement(int64_t);
 
    std::string E_SgSwitchStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSwitchStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSwitchStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSwitchStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 426
namespace stringify {
    const char* E_SgCatchOptionStmt(int64_t);
 
    std::string E_SgCatchOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCatchOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgCatchOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCatchOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 429
namespace stringify {
    const char* E_SgNamespaceDefinitionStatement(int64_t);
 
    std::string E_SgNamespaceDefinitionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceDefinitionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceDefinitionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceDefinitionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 432
namespace stringify {
    const char* E_SgAssociateStatement(int64_t);
 
    std::string E_SgAssociateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssociateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssociateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssociateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 435
namespace stringify {
    const char* E_SgFortranNonblockedDo(int64_t);
 
    std::string E_SgFortranNonblockedDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFortranNonblockedDo();
}
 
namespace Rose {
    std::string stringifyE_SgFortranNonblockedDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFortranNonblockedDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 438
namespace stringify {
    const char* E_SgFortranDo(int64_t);
 
    std::string E_SgFortranDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFortranDo();
}
 
namespace Rose {
    std::string stringifyE_SgFortranDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFortranDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 441
namespace stringify {
    const char* E_SgForAllStatement(int64_t);
 
    std::string E_SgForAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 444
namespace stringify {
    const char* E_SgUpcForAllStatement(int64_t);
 
    std::string E_SgUpcForAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcForAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcForAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcForAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 447
namespace stringify {
    const char* E_SgCAFWithTeamStatement(int64_t);
 
    std::string E_SgCAFWithTeamStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCAFWithTeamStatement();
}
 
namespace Rose {
    std::string stringifyE_SgCAFWithTeamStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCAFWithTeamStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 450
namespace stringify {
    const char* E_SgFunctionParameterScope(int64_t);
 
    std::string E_SgFunctionParameterScope(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterScope();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterScope(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterScope();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 453
namespace stringify {
    const char* E_SgRangeBasedForStatement(int64_t);
 
    std::string E_SgRangeBasedForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRangeBasedForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgRangeBasedForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRangeBasedForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 456
namespace stringify {
    const char* E_SgFunctionParameterList(int64_t);
 
    std::string E_SgFunctionParameterList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterList();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 459
namespace stringify {
    const char* E_SgTemplateVariableDeclaration(int64_t);
 
    std::string E_SgTemplateVariableDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateVariableDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateVariableDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateVariableDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 462
namespace stringify {
    const char* E_SgVariableDeclaration(int64_t);
 
    std::string E_SgVariableDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVariableDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgVariableDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVariableDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 465
namespace stringify {
    const char* E_SgVariableDefinition(int64_t);
 
    std::string E_SgVariableDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVariableDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgVariableDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVariableDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 468
namespace stringify {
    const char* E_SgEnumDeclaration(int64_t);
 
    std::string E_SgEnumDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgEnumDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 471
namespace stringify {
    const char* E_SgAsmStmt(int64_t);
 
    std::string E_SgAsmStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAsmStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 474
namespace stringify {
    const char* E_SgTemplateInstantiationDirectiveStatement(int64_t);
 
    std::string E_SgTemplateInstantiationDirectiveStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDirectiveStatement();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDirectiveStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDirectiveStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 477
namespace stringify {
    const char* E_SgUseStatement(int64_t);
 
    std::string E_SgUseStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUseStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUseStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUseStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 480
namespace stringify {
    const char* E_SgNamespaceDeclarationStatement(int64_t);
 
    std::string E_SgNamespaceDeclarationStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceDeclarationStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceDeclarationStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceDeclarationStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 483
namespace stringify {
    const char* E_SgInterfaceStatement(int64_t);
 
    std::string E_SgInterfaceStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInterfaceStatement();
}
 
namespace Rose {
    std::string stringifyE_SgInterfaceStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInterfaceStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 486
namespace stringify {
    const char* E_SgCommonBlock(int64_t);
 
    std::string E_SgCommonBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommonBlock();
}
 
namespace Rose {
    std::string stringifyE_SgCommonBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommonBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 489
namespace stringify {
    const char* E_SgTemplateTypedefDeclaration(int64_t);
 
    std::string E_SgTemplateTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 492
namespace stringify {
    const char* E_SgTemplateInstantiationTypedefDeclaration(int64_t);
 
    std::string E_SgTemplateInstantiationTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 495
namespace stringify {
    const char* E_SgTypedefDeclaration(int64_t);
 
    std::string E_SgTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 498
namespace stringify {
    const char* E_SgStatementFunctionStatement(int64_t);
 
    std::string E_SgStatementFunctionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStatementFunctionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgStatementFunctionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStatementFunctionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 501
namespace stringify {
    const char* E_SgCtorInitializerList(int64_t);
 
    std::string E_SgCtorInitializerList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCtorInitializerList();
}
 
namespace Rose {
    std::string stringifyE_SgCtorInitializerList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCtorInitializerList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 504
namespace stringify {
    const char* E_SgPragmaDeclaration(int64_t);
 
    std::string E_SgPragmaDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPragmaDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgPragmaDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPragmaDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 507
namespace stringify {
    const char* E_SgTemplateClassDeclaration(int64_t);
 
    std::string E_SgTemplateClassDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 510
namespace stringify {
    const char* E_SgTemplateInstantiationDecl(int64_t);
 
    std::string E_SgTemplateInstantiationDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 513
namespace stringify {
    const char* E_SgDerivedTypeStatement(int64_t);
 
    std::string E_SgDerivedTypeStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDerivedTypeStatement();
}
 
namespace Rose {
    std::string stringifyE_SgDerivedTypeStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDerivedTypeStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 516
namespace stringify {
    const char* E_SgModuleStatement(int64_t);
 
    std::string E_SgModuleStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModuleStatement();
}
 
namespace Rose {
    std::string stringifyE_SgModuleStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModuleStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 519
namespace stringify {
    const char* E_SgClassDeclaration(int64_t);
 
    std::string E_SgClassDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgClassDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 522
namespace stringify {
    const char* E_SgImplicitStatement(int64_t);
 
    std::string E_SgImplicitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImplicitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgImplicitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImplicitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 525
namespace stringify {
    const char* E_SgTemplateFunctionDeclaration(int64_t);
 
    std::string E_SgTemplateFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 528
namespace stringify {
    const char* E_SgTemplateMemberFunctionDeclaration(int64_t);
 
    std::string E_SgTemplateMemberFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateMemberFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateMemberFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateMemberFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 531
namespace stringify {
    const char* E_SgTemplateInstantiationMemberFunctionDecl(int64_t);
 
    std::string E_SgTemplateInstantiationMemberFunctionDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationMemberFunctionDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationMemberFunctionDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationMemberFunctionDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 534
namespace stringify {
    const char* E_SgMemberFunctionDeclaration(int64_t);
 
    std::string E_SgMemberFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 537
namespace stringify {
    const char* E_SgTemplateInstantiationFunctionDecl(int64_t);
 
    std::string E_SgTemplateInstantiationFunctionDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationFunctionDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationFunctionDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationFunctionDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 540
namespace stringify {
    const char* E_SgProgramHeaderStatement(int64_t);
 
    std::string E_SgProgramHeaderStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProgramHeaderStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProgramHeaderStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProgramHeaderStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 543
namespace stringify {
    const char* E_SgProcedureHeaderStatement(int64_t);
 
    std::string E_SgProcedureHeaderStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProcedureHeaderStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProcedureHeaderStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProcedureHeaderStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 546
namespace stringify {
    const char* E_SgEntryStatement(int64_t);
 
    std::string E_SgEntryStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEntryStatement();
}
 
namespace Rose {
    std::string stringifyE_SgEntryStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEntryStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 549
namespace stringify {
    const char* E_SgFunctionDeclaration(int64_t);
 
    std::string E_SgFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 552
namespace stringify {
    const char* E_SgIncludeDirectiveStatement(int64_t);
 
    std::string E_SgIncludeDirectiveStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIncludeDirectiveStatement();
}
 
namespace Rose {
    std::string stringifyE_SgIncludeDirectiveStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIncludeDirectiveStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 555
namespace stringify {
    const char* E_SgOmpThreadprivateStatement(int64_t);
 
    std::string E_SgOmpThreadprivateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpThreadprivateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpThreadprivateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpThreadprivateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 558
namespace stringify {
    const char* E_SgOmpRequiresStatement(int64_t);
 
    std::string E_SgOmpRequiresStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpRequiresStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpRequiresStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpRequiresStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 561
namespace stringify {
    const char* E_SgOmpTaskwaitStatement(int64_t);
 
    std::string E_SgOmpTaskwaitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskwaitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskwaitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskwaitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 564
namespace stringify {
    const char* E_SgStmtDeclarationStatement(int64_t);
 
    std::string E_SgStmtDeclarationStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStmtDeclarationStatement();
}
 
namespace Rose {
    std::string stringifyE_SgStmtDeclarationStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStmtDeclarationStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 567
namespace stringify {
    const char* E_SgStaticAssertionDeclaration(int64_t);
 
    std::string E_SgStaticAssertionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStaticAssertionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgStaticAssertionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStaticAssertionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 570
namespace stringify {
    const char* E_SgOmpDeclareSimdStatement(int64_t);
 
    std::string E_SgOmpDeclareSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDeclareSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDeclareSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDeclareSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 573
namespace stringify {
    const char* E_SgExprStatement(int64_t);
 
    std::string E_SgExprStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExprStatement();
}
 
namespace Rose {
    std::string stringifyE_SgExprStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExprStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 576
namespace stringify {
    const char* E_SgLabelStatement(int64_t);
 
    std::string E_SgLabelStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLabelStatement();
}
 
namespace Rose {
    std::string stringifyE_SgLabelStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLabelStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 579
namespace stringify {
    const char* E_SgCaseOptionStmt(int64_t);
 
    std::string E_SgCaseOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCaseOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgCaseOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCaseOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 582
namespace stringify {
    const char* E_SgTryStmt(int64_t);
 
    std::string E_SgTryStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTryStmt();
}
 
namespace Rose {
    std::string stringifyE_SgTryStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTryStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 585
namespace stringify {
    const char* E_SgDefaultOptionStmt(int64_t);
 
    std::string E_SgDefaultOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDefaultOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgDefaultOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDefaultOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 588
namespace stringify {
    const char* E_SgReturnStmt(int64_t);
 
    std::string E_SgReturnStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReturnStmt();
}
 
namespace Rose {
    std::string stringifyE_SgReturnStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReturnStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 591
namespace stringify {
    const char* E_SgSpawnStmt(int64_t);
 
    std::string E_SgSpawnStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSpawnStmt();
}
 
namespace Rose {
    std::string stringifyE_SgSpawnStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSpawnStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 594
namespace stringify {
    const char* E_SgForInitStatement(int64_t);
 
    std::string E_SgForInitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForInitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForInitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForInitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 597
namespace stringify {
    const char* E_SgCatchStatementSeq(int64_t);
 
    std::string E_SgCatchStatementSeq(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCatchStatementSeq();
}
 
namespace Rose {
    std::string stringifyE_SgCatchStatementSeq(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCatchStatementSeq();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 600
namespace stringify {
    const char* E_SgProcessControlStatement(int64_t);
 
    std::string E_SgProcessControlStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProcessControlStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProcessControlStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProcessControlStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 603
namespace stringify {
    const char* E_SgPrintStatement(int64_t);
 
    std::string E_SgPrintStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPrintStatement();
}
 
namespace Rose {
    std::string stringifyE_SgPrintStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPrintStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 606
namespace stringify {
    const char* E_SgReadStatement(int64_t);
 
    std::string E_SgReadStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReadStatement();
}
 
namespace Rose {
    std::string stringifyE_SgReadStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReadStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 609
namespace stringify {
    const char* E_SgWriteStatement(int64_t);
 
    std::string E_SgWriteStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWriteStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWriteStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWriteStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 612
namespace stringify {
    const char* E_SgOpenStatement(int64_t);
 
    std::string E_SgOpenStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOpenStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOpenStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOpenStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 615
namespace stringify {
    const char* E_SgCloseStatement(int64_t);
 
    std::string E_SgCloseStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCloseStatement();
}
 
namespace Rose {
    std::string stringifyE_SgCloseStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCloseStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 618
namespace stringify {
    const char* E_SgInquireStatement(int64_t);
 
    std::string E_SgInquireStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInquireStatement();
}
 
namespace Rose {
    std::string stringifyE_SgInquireStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInquireStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 621
namespace stringify {
    const char* E_SgFlushStatement(int64_t);
 
    std::string E_SgFlushStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFlushStatement();
}
 
namespace Rose {
    std::string stringifyE_SgFlushStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFlushStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 624
namespace stringify {
    const char* E_SgBackspaceStatement(int64_t);
 
    std::string E_SgBackspaceStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBackspaceStatement();
}
 
namespace Rose {
    std::string stringifyE_SgBackspaceStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBackspaceStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 627
namespace stringify {
    const char* E_SgRewindStatement(int64_t);
 
    std::string E_SgRewindStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRewindStatement();
}
 
namespace Rose {
    std::string stringifyE_SgRewindStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRewindStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 630
namespace stringify {
    const char* E_SgEndfileStatement(int64_t);
 
    std::string E_SgEndfileStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEndfileStatement();
}
 
namespace Rose {
    std::string stringifyE_SgEndfileStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEndfileStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 633
namespace stringify {
    const char* E_SgWaitStatement(int64_t);
 
    std::string E_SgWaitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWaitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWaitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWaitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 636
namespace stringify {
    const char* E_SgIOStatement(int64_t);
 
    std::string E_SgIOStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIOStatement();
}
 
namespace Rose {
    std::string stringifyE_SgIOStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIOStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 639
namespace stringify {
    const char* E_SgWhereStatement(int64_t);
 
    std::string E_SgWhereStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWhereStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWhereStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWhereStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 642
namespace stringify {
    const char* E_SgElseWhereStatement(int64_t);
 
    std::string E_SgElseWhereStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElseWhereStatement();
}
 
namespace Rose {
    std::string stringifyE_SgElseWhereStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElseWhereStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 645
namespace stringify {
    const char* E_SgNullifyStatement(int64_t);
 
    std::string E_SgNullifyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNullifyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNullifyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNullifyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 648
namespace stringify {
    const char* E_SgArithmeticIfStatement(int64_t);
 
    std::string E_SgArithmeticIfStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArithmeticIfStatement();
}
 
namespace Rose {
    std::string stringifyE_SgArithmeticIfStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArithmeticIfStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 651
namespace stringify {
    const char* E_SgAssignStatement(int64_t);
 
    std::string E_SgAssignStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssignStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 654
namespace stringify {
    const char* E_SgComputedGotoStatement(int64_t);
 
    std::string E_SgComputedGotoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComputedGotoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgComputedGotoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComputedGotoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 657
namespace stringify {
    const char* E_SgAssignedGotoStatement(int64_t);
 
    std::string E_SgAssignedGotoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignedGotoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssignedGotoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignedGotoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 660
namespace stringify {
    const char* E_SgAllocateStatement(int64_t);
 
    std::string E_SgAllocateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAllocateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAllocateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAllocateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 663
namespace stringify {
    const char* E_SgDeallocateStatement(int64_t);
 
    std::string E_SgDeallocateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeallocateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgDeallocateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeallocateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 666
namespace stringify {
    const char* E_SgUpcNotifyStatement(int64_t);
 
    std::string E_SgUpcNotifyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcNotifyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcNotifyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcNotifyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 669
namespace stringify {
    const char* E_SgUpcWaitStatement(int64_t);
 
    std::string E_SgUpcWaitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcWaitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcWaitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcWaitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 672
namespace stringify {
    const char* E_SgUpcBarrierStatement(int64_t);
 
    std::string E_SgUpcBarrierStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcBarrierStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcBarrierStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcBarrierStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 675
namespace stringify {
    const char* E_SgOmpMasterStatement(int64_t);
 
    std::string E_SgOmpMasterStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMasterStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMasterStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMasterStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 678
namespace stringify {
    const char* E_SgOmpSectionStatement(int64_t);
 
    std::string E_SgOmpSectionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSectionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSectionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSectionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 681
namespace stringify {
    const char* E_SgOmpWorkshareStatement(int64_t);
 
    std::string E_SgOmpWorkshareStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpWorkshareStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpWorkshareStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpWorkshareStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 684
namespace stringify {
    const char* E_SgUpirSpmdStatement(int64_t);
 
    std::string E_SgUpirSpmdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirSpmdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpirSpmdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirSpmdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 687
namespace stringify {
    const char* E_SgOmpTeamsStatement(int64_t);
 
    std::string E_SgOmpTeamsStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 690
namespace stringify {
    const char* E_SgOmpSingleStatement(int64_t);
 
    std::string E_SgOmpSingleStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSingleStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSingleStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSingleStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 693
namespace stringify {
    const char* E_SgOmpAtomicStatement(int64_t);
 
    std::string E_SgOmpAtomicStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAtomicStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAtomicStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAtomicStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 696
namespace stringify {
    const char* E_SgOmpScanStatement(int64_t);
 
    std::string E_SgOmpScanStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpScanStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpScanStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpScanStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 699
namespace stringify {
    const char* E_SgOmpMetadirectiveStatement(int64_t);
 
    std::string E_SgOmpMetadirectiveStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMetadirectiveStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMetadirectiveStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMetadirectiveStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 702
namespace stringify {
    const char* E_SgOmpLoopStatement(int64_t);
 
    std::string E_SgOmpLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 705
namespace stringify {
    const char* E_SgOmpOrderedStatement(int64_t);
 
    std::string E_SgOmpOrderedStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpOrderedStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpOrderedStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpOrderedStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 708
namespace stringify {
    const char* E_SgOmpTaskgroupStatement(int64_t);
 
    std::string E_SgOmpTaskgroupStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskgroupStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskgroupStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskgroupStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 711
namespace stringify {
    const char* E_SgOmpTaskloopStatement(int64_t);
 
    std::string E_SgOmpTaskloopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskloopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskloopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskloopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 714
namespace stringify {
    const char* E_SgOmpDepobjStatement(int64_t);
 
    std::string E_SgOmpDepobjStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDepobjStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDepobjStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDepobjStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 717
namespace stringify {
    const char* E_SgOmpTargetEnterDataStatement(int64_t);
 
    std::string E_SgOmpTargetEnterDataStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetEnterDataStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetEnterDataStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetEnterDataStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 720
namespace stringify {
    const char* E_SgOmpTargetExitDataStatement(int64_t);
 
    std::string E_SgOmpTargetExitDataStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetExitDataStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetExitDataStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetExitDataStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 723
namespace stringify {
    const char* E_SgOmpParallelMasterStatement(int64_t);
 
    std::string E_SgOmpParallelMasterStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpParallelMasterStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpParallelMasterStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpParallelMasterStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 726
namespace stringify {
    const char* E_SgOmpMasterTaskloopStatement(int64_t);
 
    std::string E_SgOmpMasterTaskloopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMasterTaskloopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMasterTaskloopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMasterTaskloopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 729
namespace stringify {
    const char* E_SgOmpTaskStatement(int64_t);
 
    std::string E_SgOmpTaskStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 732
namespace stringify {
    const char* E_SgOmpDoStatement(int64_t);
 
    std::string E_SgOmpDoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 735
namespace stringify {
    const char* E_SgOmpSectionsStatement(int64_t);
 
    std::string E_SgOmpSectionsStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSectionsStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSectionsStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSectionsStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 738
namespace stringify {
    const char* E_SgUpirTaskStatement(int64_t);
 
    std::string E_SgUpirTaskStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirTaskStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpirTaskStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirTaskStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 741
namespace stringify {
    const char* E_SgOmpTargetDataStatement(int64_t);
 
    std::string E_SgOmpTargetDataStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetDataStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetDataStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetDataStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 744
namespace stringify {
    const char* E_SgOmpTargetParallelForStatement(int64_t);
 
    std::string E_SgOmpTargetParallelForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetParallelForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetParallelForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetParallelForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 747
namespace stringify {
    const char* E_SgOmpParallelLoopStatement(int64_t);
 
    std::string E_SgOmpParallelLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpParallelLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpParallelLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpParallelLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 750
namespace stringify {
    const char* E_SgOmpTargetParallelStatement(int64_t);
 
    std::string E_SgOmpTargetParallelStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetParallelStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetParallelStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetParallelStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 753
namespace stringify {
    const char* E_SgOmpTargetParallelForSimdStatement(int64_t);
 
    std::string E_SgOmpTargetParallelForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetParallelForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetParallelForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetParallelForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 756
namespace stringify {
    const char* E_SgOmpTargetParallelLoopStatement(int64_t);
 
    std::string E_SgOmpTargetParallelLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetParallelLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetParallelLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetParallelLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 759
namespace stringify {
    const char* E_SgOmpTargetSimdStatement(int64_t);
 
    std::string E_SgOmpTargetSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 762
namespace stringify {
    const char* E_SgOmpTargetTeamsStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 765
namespace stringify {
    const char* E_SgOmpTargetTeamsDistributeStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsDistributeStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsDistributeStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsDistributeStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsDistributeStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 768
namespace stringify {
    const char* E_SgOmpTargetTeamsDistributeSimdStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsDistributeSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsDistributeSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsDistributeSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsDistributeSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 771
namespace stringify {
    const char* E_SgOmpTargetTeamsLoopStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 774
namespace stringify {
    const char* E_SgOmpTargetTeamsDistributeParallelForStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsDistributeParallelForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsDistributeParallelForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsDistributeParallelForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsDistributeParallelForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 777
namespace stringify {
    const char* E_SgOmpTargetTeamsDistributeParallelForSimdStatement(int64_t);
 
    std::string E_SgOmpTargetTeamsDistributeParallelForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetTeamsDistributeParallelForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetTeamsDistributeParallelForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetTeamsDistributeParallelForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 780
namespace stringify {
    const char* E_SgOmpDistributeSimdStatement(int64_t);
 
    std::string E_SgOmpDistributeSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDistributeSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDistributeSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDistributeSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 783
namespace stringify {
    const char* E_SgOmpDistributeParallelForStatement(int64_t);
 
    std::string E_SgOmpDistributeParallelForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDistributeParallelForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDistributeParallelForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDistributeParallelForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 786
namespace stringify {
    const char* E_SgOmpDistributeParallelForSimdStatement(int64_t);
 
    std::string E_SgOmpDistributeParallelForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDistributeParallelForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDistributeParallelForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDistributeParallelForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 789
namespace stringify {
    const char* E_SgOmpTaskloopSimdStatement(int64_t);
 
    std::string E_SgOmpTaskloopSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskloopSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskloopSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskloopSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 792
namespace stringify {
    const char* E_SgOmpMasterTaskloopSimdStatement(int64_t);
 
    std::string E_SgOmpMasterTaskloopSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMasterTaskloopSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMasterTaskloopSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMasterTaskloopSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 795
namespace stringify {
    const char* E_SgOmpParallelMasterTaskloopStatement(int64_t);
 
    std::string E_SgOmpParallelMasterTaskloopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpParallelMasterTaskloopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpParallelMasterTaskloopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpParallelMasterTaskloopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 798
namespace stringify {
    const char* E_SgOmpParallelMasterTaskloopSimdStatement(int64_t);
 
    std::string E_SgOmpParallelMasterTaskloopSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpParallelMasterTaskloopSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpParallelMasterTaskloopSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpParallelMasterTaskloopSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 801
namespace stringify {
    const char* E_SgOmpTeamsDistributeStatement(int64_t);
 
    std::string E_SgOmpTeamsDistributeStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsDistributeStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsDistributeStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsDistributeStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 804
namespace stringify {
    const char* E_SgOmpTeamsDistributeSimdStatement(int64_t);
 
    std::string E_SgOmpTeamsDistributeSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsDistributeSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsDistributeSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsDistributeSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 807
namespace stringify {
    const char* E_SgOmpTeamsDistributeParallelForStatement(int64_t);
 
    std::string E_SgOmpTeamsDistributeParallelForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsDistributeParallelForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsDistributeParallelForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsDistributeParallelForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 810
namespace stringify {
    const char* E_SgOmpTeamsDistributeParallelForSimdStatement(int64_t);
 
    std::string E_SgOmpTeamsDistributeParallelForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsDistributeParallelForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsDistributeParallelForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsDistributeParallelForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 813
namespace stringify {
    const char* E_SgOmpTeamsLoopStatement(int64_t);
 
    std::string E_SgOmpTeamsLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTeamsLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTeamsLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTeamsLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 816
namespace stringify {
    const char* E_SgOmpForSimdStatement(int64_t);
 
    std::string E_SgOmpForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 819
namespace stringify {
    const char* E_SgOmpCriticalStatement(int64_t);
 
    std::string E_SgOmpCriticalStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCriticalStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCriticalStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCriticalStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 822
namespace stringify {
    const char* E_SgOmpDistributeStatement(int64_t);
 
    std::string E_SgOmpDistributeStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDistributeStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDistributeStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDistributeStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 825
namespace stringify {
    const char* E_SgOmpUnrollStatement(int64_t);
 
    std::string E_SgOmpUnrollStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpUnrollStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpUnrollStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpUnrollStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 828
namespace stringify {
    const char* E_SgOmpTileStatement(int64_t);
 
    std::string E_SgOmpTileStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTileStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTileStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTileStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 831
namespace stringify {
    const char* E_SgUpirLoopStatement(int64_t);
 
    std::string E_SgUpirLoopStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirLoopStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpirLoopStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirLoopStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 834
namespace stringify {
    const char* E_SgUpirFieldBodyStatement(int64_t);
 
    std::string E_SgUpirFieldBodyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirFieldBodyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpirFieldBodyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirFieldBodyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 837
namespace stringify {
    const char* E_SgUpirBodyStatement(int64_t);
 
    std::string E_SgUpirBodyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpirBodyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpirBodyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpirBodyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 840
namespace stringify {
    const char* E_SgOmpFlushStatement(int64_t);
 
    std::string E_SgOmpFlushStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFlushStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFlushStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFlushStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 843
namespace stringify {
    const char* E_SgOmpAllocateStatement(int64_t);
 
    std::string E_SgOmpAllocateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAllocateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAllocateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAllocateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 846
namespace stringify {
    const char* E_SgWithStatement(int64_t);
 
    std::string E_SgWithStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWithStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWithStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWithStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 849
namespace stringify {
    const char* E_SgAssertStmt(int64_t);
 
    std::string E_SgAssertStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssertStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAssertStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssertStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 852
namespace stringify {
    const char* E_SgExecStatement(int64_t);
 
    std::string E_SgExecStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExecStatement();
}
 
namespace Rose {
    std::string stringifyE_SgExecStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExecStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 855
namespace stringify {
    const char* E_SgSyncAllStatement(int64_t);
 
    std::string E_SgSyncAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 858
namespace stringify {
    const char* E_SgSyncImagesStatement(int64_t);
 
    std::string E_SgSyncImagesStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncImagesStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncImagesStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncImagesStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 861
namespace stringify {
    const char* E_SgSyncMemoryStatement(int64_t);
 
    std::string E_SgSyncMemoryStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncMemoryStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncMemoryStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncMemoryStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 864
namespace stringify {
    const char* E_SgSyncTeamStatement(int64_t);
 
    std::string E_SgSyncTeamStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncTeamStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncTeamStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncTeamStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 867
namespace stringify {
    const char* E_SgLockStatement(int64_t);
 
    std::string E_SgLockStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLockStatement();
}
 
namespace Rose {
    std::string stringifyE_SgLockStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLockStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 870
namespace stringify {
    const char* E_SgUnlockStatement(int64_t);
 
    std::string E_SgUnlockStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnlockStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUnlockStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnlockStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 873
namespace stringify {
    const char* E_SgImageControlStatement(int64_t);
 
    std::string E_SgImageControlStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImageControlStatement();
}
 
namespace Rose {
    std::string stringifyE_SgImageControlStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImageControlStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 876
namespace stringify {
    const char* E_SgExpressionRoot(int64_t);
 
    std::string E_SgExpressionRoot(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExpressionRoot();
}
 
namespace Rose {
    std::string stringifyE_SgExpressionRoot(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExpressionRoot();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 879
namespace stringify {
    const char* E_SgMinusOp(int64_t);
 
    std::string E_SgMinusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 882
namespace stringify {
    const char* E_SgUnaryAddOp(int64_t);
 
    std::string E_SgUnaryAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnaryAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgUnaryAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnaryAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 885
namespace stringify {
    const char* E_SgNotOp(int64_t);
 
    std::string E_SgNotOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNotOp();
}
 
namespace Rose {
    std::string stringifyE_SgNotOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNotOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 888
namespace stringify {
    const char* E_SgPointerDerefExp(int64_t);
 
    std::string E_SgPointerDerefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerDerefExp();
}
 
namespace Rose {
    std::string stringifyE_SgPointerDerefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerDerefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 891
namespace stringify {
    const char* E_SgAddressOfOp(int64_t);
 
    std::string E_SgAddressOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAddressOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgAddressOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAddressOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 894
namespace stringify {
    const char* E_SgMinusMinusOp(int64_t);
 
    std::string E_SgMinusMinusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusMinusOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusMinusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusMinusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 897
namespace stringify {
    const char* E_SgPlusPlusOp(int64_t);
 
    std::string E_SgPlusPlusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPlusPlusOp();
}
 
namespace Rose {
    std::string stringifyE_SgPlusPlusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPlusPlusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 900
namespace stringify {
    const char* E_SgBitComplementOp(int64_t);
 
    std::string E_SgBitComplementOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitComplementOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitComplementOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitComplementOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 903
namespace stringify {
    const char* E_SgCastExp(int64_t);
 
    std::string E_SgCastExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCastExp();
}
 
namespace Rose {
    std::string stringifyE_SgCastExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCastExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 906
namespace stringify {
    const char* E_SgThrowOp(int64_t);
 
    std::string E_SgThrowOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgThrowOp();
}
 
namespace Rose {
    std::string stringifyE_SgThrowOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgThrowOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 909
namespace stringify {
    const char* E_SgRealPartOp(int64_t);
 
    std::string E_SgRealPartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRealPartOp();
}
 
namespace Rose {
    std::string stringifyE_SgRealPartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRealPartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 912
namespace stringify {
    const char* E_SgImagPartOp(int64_t);
 
    std::string E_SgImagPartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImagPartOp();
}
 
namespace Rose {
    std::string stringifyE_SgImagPartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImagPartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 915
namespace stringify {
    const char* E_SgConjugateOp(int64_t);
 
    std::string E_SgConjugateOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConjugateOp();
}
 
namespace Rose {
    std::string stringifyE_SgConjugateOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConjugateOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 918
namespace stringify {
    const char* E_SgUserDefinedUnaryOp(int64_t);
 
    std::string E_SgUserDefinedUnaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUserDefinedUnaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUserDefinedUnaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUserDefinedUnaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 921
namespace stringify {
    const char* E_SgMatrixTransposeOp(int64_t);
 
    std::string E_SgMatrixTransposeOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMatrixTransposeOp();
}
 
namespace Rose {
    std::string stringifyE_SgMatrixTransposeOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMatrixTransposeOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 924
namespace stringify {
    const char* E_SgUnaryOp(int64_t);
 
    std::string E_SgUnaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUnaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 927
namespace stringify {
    const char* E_SgArrowExp(int64_t);
 
    std::string E_SgArrowExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrowExp();
}
 
namespace Rose {
    std::string stringifyE_SgArrowExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrowExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 930
namespace stringify {
    const char* E_SgDotExp(int64_t);
 
    std::string E_SgDotExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDotExp();
}
 
namespace Rose {
    std::string stringifyE_SgDotExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDotExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 933
namespace stringify {
    const char* E_SgDotStarOp(int64_t);
 
    std::string E_SgDotStarOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDotStarOp();
}
 
namespace Rose {
    std::string stringifyE_SgDotStarOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDotStarOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 936
namespace stringify {
    const char* E_SgArrowStarOp(int64_t);
 
    std::string E_SgArrowStarOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrowStarOp();
}
 
namespace Rose {
    std::string stringifyE_SgArrowStarOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrowStarOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 939
namespace stringify {
    const char* E_SgEqualityOp(int64_t);
 
    std::string E_SgEqualityOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEqualityOp();
}
 
namespace Rose {
    std::string stringifyE_SgEqualityOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEqualityOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 942
namespace stringify {
    const char* E_SgLessThanOp(int64_t);
 
    std::string E_SgLessThanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLessThanOp();
}
 
namespace Rose {
    std::string stringifyE_SgLessThanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLessThanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 945
namespace stringify {
    const char* E_SgGreaterThanOp(int64_t);
 
    std::string E_SgGreaterThanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGreaterThanOp();
}
 
namespace Rose {
    std::string stringifyE_SgGreaterThanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGreaterThanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 948
namespace stringify {
    const char* E_SgNotEqualOp(int64_t);
 
    std::string E_SgNotEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNotEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgNotEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNotEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 951
namespace stringify {
    const char* E_SgLessOrEqualOp(int64_t);
 
    std::string E_SgLessOrEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLessOrEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgLessOrEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLessOrEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 954
namespace stringify {
    const char* E_SgGreaterOrEqualOp(int64_t);
 
    std::string E_SgGreaterOrEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGreaterOrEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgGreaterOrEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGreaterOrEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 957
namespace stringify {
    const char* E_SgAddOp(int64_t);
 
    std::string E_SgAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 960
namespace stringify {
    const char* E_SgSubtractOp(int64_t);
 
    std::string E_SgSubtractOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSubtractOp();
}
 
namespace Rose {
    std::string stringifyE_SgSubtractOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSubtractOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 963
namespace stringify {
    const char* E_SgMultiplyOp(int64_t);
 
    std::string E_SgMultiplyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMultiplyOp();
}
 
namespace Rose {
    std::string stringifyE_SgMultiplyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMultiplyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 966
namespace stringify {
    const char* E_SgDivideOp(int64_t);
 
    std::string E_SgDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 969
namespace stringify {
    const char* E_SgIntegerDivideOp(int64_t);
 
    std::string E_SgIntegerDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIntegerDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgIntegerDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIntegerDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 972
namespace stringify {
    const char* E_SgModOp(int64_t);
 
    std::string E_SgModOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModOp();
}
 
namespace Rose {
    std::string stringifyE_SgModOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 975
namespace stringify {
    const char* E_SgAndOp(int64_t);
 
    std::string E_SgAndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAndOp();
}
 
namespace Rose {
    std::string stringifyE_SgAndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 978
namespace stringify {
    const char* E_SgOrOp(int64_t);
 
    std::string E_SgOrOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOrOp();
}
 
namespace Rose {
    std::string stringifyE_SgOrOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOrOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 981
namespace stringify {
    const char* E_SgBitXorOp(int64_t);
 
    std::string E_SgBitXorOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitXorOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitXorOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitXorOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 984
namespace stringify {
    const char* E_SgBitAndOp(int64_t);
 
    std::string E_SgBitAndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitAndOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitAndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitAndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 987
namespace stringify {
    const char* E_SgBitOrOp(int64_t);
 
    std::string E_SgBitOrOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitOrOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitOrOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitOrOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 990
namespace stringify {
    const char* E_SgBitEqvOp(int64_t);
 
    std::string E_SgBitEqvOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitEqvOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitEqvOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitEqvOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 993
namespace stringify {
    const char* E_SgCommaOpExp(int64_t);
 
    std::string E_SgCommaOpExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommaOpExp();
}
 
namespace Rose {
    std::string stringifyE_SgCommaOpExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommaOpExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 996
namespace stringify {
    const char* E_SgLshiftOp(int64_t);
 
    std::string E_SgLshiftOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLshiftOp();
}
 
namespace Rose {
    std::string stringifyE_SgLshiftOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLshiftOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 999
namespace stringify {
    const char* E_SgRshiftOp(int64_t);
 
    std::string E_SgRshiftOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRshiftOp();
}
 
namespace Rose {
    std::string stringifyE_SgRshiftOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRshiftOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1002
namespace stringify {
    const char* E_SgPntrArrRefExp(int64_t);
 
    std::string E_SgPntrArrRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPntrArrRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgPntrArrRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPntrArrRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1005
namespace stringify {
    const char* E_SgScopeOp(int64_t);
 
    std::string E_SgScopeOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgScopeOp();
}
 
namespace Rose {
    std::string stringifyE_SgScopeOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgScopeOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1008
namespace stringify {
    const char* E_SgAssignOp(int64_t);
 
    std::string E_SgAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1011
namespace stringify {
    const char* E_SgExponentiationOp(int64_t);
 
    std::string E_SgExponentiationOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExponentiationOp();
}
 
namespace Rose {
    std::string stringifyE_SgExponentiationOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExponentiationOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1014
namespace stringify {
    const char* E_SgConcatenationOp(int64_t);
 
    std::string E_SgConcatenationOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConcatenationOp();
}
 
namespace Rose {
    std::string stringifyE_SgConcatenationOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConcatenationOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1017
namespace stringify {
    const char* E_SgPointerAssignOp(int64_t);
 
    std::string E_SgPointerAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgPointerAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1020
namespace stringify {
    const char* E_SgUserDefinedBinaryOp(int64_t);
 
    std::string E_SgUserDefinedBinaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUserDefinedBinaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUserDefinedBinaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUserDefinedBinaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1023
namespace stringify {
    const char* E_SgPlusAssignOp(int64_t);
 
    std::string E_SgPlusAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPlusAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgPlusAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPlusAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1026
namespace stringify {
    const char* E_SgMinusAssignOp(int64_t);
 
    std::string E_SgMinusAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1029
namespace stringify {
    const char* E_SgAndAssignOp(int64_t);
 
    std::string E_SgAndAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAndAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgAndAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAndAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1032
namespace stringify {
    const char* E_SgIorAssignOp(int64_t);
 
    std::string E_SgIorAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIorAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgIorAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIorAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1035
namespace stringify {
    const char* E_SgMultAssignOp(int64_t);
 
    std::string E_SgMultAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMultAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgMultAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMultAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1038
namespace stringify {
    const char* E_SgDivAssignOp(int64_t);
 
    std::string E_SgDivAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDivAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgDivAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDivAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1041
namespace stringify {
    const char* E_SgModAssignOp(int64_t);
 
    std::string E_SgModAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgModAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1044
namespace stringify {
    const char* E_SgXorAssignOp(int64_t);
 
    std::string E_SgXorAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgXorAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgXorAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgXorAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1047
namespace stringify {
    const char* E_SgLshiftAssignOp(int64_t);
 
    std::string E_SgLshiftAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLshiftAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgLshiftAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLshiftAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1050
namespace stringify {
    const char* E_SgRshiftAssignOp(int64_t);
 
    std::string E_SgRshiftAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRshiftAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgRshiftAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRshiftAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1053
namespace stringify {
    const char* E_SgIntegerDivideAssignOp(int64_t);
 
    std::string E_SgIntegerDivideAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIntegerDivideAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgIntegerDivideAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIntegerDivideAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1056
namespace stringify {
    const char* E_SgExponentiationAssignOp(int64_t);
 
    std::string E_SgExponentiationAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExponentiationAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgExponentiationAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExponentiationAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1059
namespace stringify {
    const char* E_SgCompoundAssignOp(int64_t);
 
    std::string E_SgCompoundAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCompoundAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgCompoundAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCompoundAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1062
namespace stringify {
    const char* E_SgMembershipOp(int64_t);
 
    std::string E_SgMembershipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMembershipOp();
}
 
namespace Rose {
    std::string stringifyE_SgMembershipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMembershipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1065
namespace stringify {
    const char* E_SgSpaceshipOp(int64_t);
 
    std::string E_SgSpaceshipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSpaceshipOp();
}
 
namespace Rose {
    std::string stringifyE_SgSpaceshipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSpaceshipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1068
namespace stringify {
    const char* E_SgNonMembershipOp(int64_t);
 
    std::string E_SgNonMembershipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonMembershipOp();
}
 
namespace Rose {
    std::string stringifyE_SgNonMembershipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonMembershipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1071
namespace stringify {
    const char* E_SgIsOp(int64_t);
 
    std::string E_SgIsOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIsOp();
}
 
namespace Rose {
    std::string stringifyE_SgIsOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIsOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1074
namespace stringify {
    const char* E_SgIsNotOp(int64_t);
 
    std::string E_SgIsNotOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIsNotOp();
}
 
namespace Rose {
    std::string stringifyE_SgIsNotOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIsNotOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1077
namespace stringify {
    const char* E_SgElementwiseMultiplyOp(int64_t);
 
    std::string E_SgElementwiseMultiplyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseMultiplyOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseMultiplyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseMultiplyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1080
namespace stringify {
    const char* E_SgElementwisePowerOp(int64_t);
 
    std::string E_SgElementwisePowerOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwisePowerOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwisePowerOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwisePowerOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1083
namespace stringify {
    const char* E_SgElementwiseLeftDivideOp(int64_t);
 
    std::string E_SgElementwiseLeftDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseLeftDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseLeftDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseLeftDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1086
namespace stringify {
    const char* E_SgElementwiseDivideOp(int64_t);
 
    std::string E_SgElementwiseDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1089
namespace stringify {
    const char* E_SgElementwiseAddOp(int64_t);
 
    std::string E_SgElementwiseAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1092
namespace stringify {
    const char* E_SgElementwiseSubtractOp(int64_t);
 
    std::string E_SgElementwiseSubtractOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseSubtractOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseSubtractOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseSubtractOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1095
namespace stringify {
    const char* E_SgElementwiseOp(int64_t);
 
    std::string E_SgElementwiseOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1098
namespace stringify {
    const char* E_SgPowerOp(int64_t);
 
    std::string E_SgPowerOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPowerOp();
}
 
namespace Rose {
    std::string stringifyE_SgPowerOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPowerOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1101
namespace stringify {
    const char* E_SgLeftDivideOp(int64_t);
 
    std::string E_SgLeftDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLeftDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgLeftDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLeftDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1104
namespace stringify {
    const char* E_SgSIMDAddOp(int64_t);
 
    std::string E_SgSIMDAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1107
namespace stringify {
    const char* E_SgSIMDSubOp(int64_t);
 
    std::string E_SgSIMDSubOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDSubOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDSubOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDSubOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1110
namespace stringify {
    const char* E_SgSIMDMulOp(int64_t);
 
    std::string E_SgSIMDMulOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDMulOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDMulOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDMulOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1113
namespace stringify {
    const char* E_SgSIMDDivOp(int64_t);
 
    std::string E_SgSIMDDivOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDDivOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDDivOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDDivOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1116
namespace stringify {
    const char* E_SgSIMDFmaOp(int64_t);
 
    std::string E_SgSIMDFmaOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDFmaOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDFmaOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDFmaOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1119
namespace stringify {
    const char* E_SgSIMDBinaryOp(int64_t);
 
    std::string E_SgSIMDBinaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDBinaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDBinaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDBinaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1122
namespace stringify {
    const char* E_SgSIMDLoad(int64_t);
 
    std::string E_SgSIMDLoad(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDLoad();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDLoad(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDLoad();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1125
namespace stringify {
    const char* E_SgSIMDBroadcast(int64_t);
 
    std::string E_SgSIMDBroadcast(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDBroadcast();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDBroadcast(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDBroadcast();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1128
namespace stringify {
    const char* E_SgSIMDStore(int64_t);
 
    std::string E_SgSIMDStore(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDStore();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDStore(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDStore();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1131
namespace stringify {
    const char* E_SgSIMDPartialStore(int64_t);
 
    std::string E_SgSIMDPartialStore(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDPartialStore();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDPartialStore(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDPartialStore();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1134
namespace stringify {
    const char* E_SgSIMDScalarStore(int64_t);
 
    std::string E_SgSIMDScalarStore(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDScalarStore();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDScalarStore(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDScalarStore();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1137
namespace stringify {
    const char* E_SgSIMDGather(int64_t);
 
    std::string E_SgSIMDGather(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDGather();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDGather(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDGather();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1140
namespace stringify {
    const char* E_SgSIMDExplicitGather(int64_t);
 
    std::string E_SgSIMDExplicitGather(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDExplicitGather();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDExplicitGather(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDExplicitGather();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1143
namespace stringify {
    const char* E_SgSIMDScatter(int64_t);
 
    std::string E_SgSIMDScatter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSIMDScatter();
}
 
namespace Rose {
    std::string stringifyE_SgSIMDScatter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSIMDScatter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1146
namespace stringify {
    const char* E_SgBinaryOp(int64_t);
 
    std::string E_SgBinaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBinaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgBinaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBinaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1149
namespace stringify {
    const char* E_SgListExp(int64_t);
 
    std::string E_SgListExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgListExp();
}
 
namespace Rose {
    std::string stringifyE_SgListExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgListExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1152
namespace stringify {
    const char* E_SgTupleExp(int64_t);
 
    std::string E_SgTupleExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTupleExp();
}
 
namespace Rose {
    std::string stringifyE_SgTupleExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTupleExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1155
namespace stringify {
    const char* E_SgMatrixExp(int64_t);
 
    std::string E_SgMatrixExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMatrixExp();
}
 
namespace Rose {
    std::string stringifyE_SgMatrixExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMatrixExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1158
namespace stringify {
    const char* E_SgExprListExp(int64_t);
 
    std::string E_SgExprListExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExprListExp();
}
 
namespace Rose {
    std::string stringifyE_SgExprListExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExprListExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1161
namespace stringify {
    const char* E_SgComplexVal(int64_t);
 
    std::string E_SgComplexVal(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComplexVal();
}
 
namespace Rose {
    std::string stringifyE_SgComplexVal(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComplexVal();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1164
namespace stringify {
    const char* E_SgCudaKernelCallExp(int64_t);
 
    std::string E_SgCudaKernelCallExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCudaKernelCallExp();
}
 
namespace Rose {
    std::string stringifyE_SgCudaKernelCallExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCudaKernelCallExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1167
namespace stringify {
    const char* E_SgFunctionCallExp(int64_t);
 
    std::string E_SgFunctionCallExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionCallExp();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionCallExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionCallExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1170
namespace stringify {
    const char* E_SgCallExpression(int64_t);
 
    std::string E_SgCallExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCallExpression();
}
 
namespace Rose {
    std::string stringifyE_SgCallExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCallExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1173
namespace stringify {
    const char* E_SgSizeOfOp(int64_t);
 
    std::string E_SgSizeOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSizeOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgSizeOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSizeOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1176
namespace stringify {
    const char* E_SgUpcLocalsizeofExpression(int64_t);
 
    std::string E_SgUpcLocalsizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcLocalsizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcLocalsizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcLocalsizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1179
namespace stringify {
    const char* E_SgUpcBlocksizeofExpression(int64_t);
 
    std::string E_SgUpcBlocksizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcBlocksizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcBlocksizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcBlocksizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1182
namespace stringify {
    const char* E_SgUpcElemsizeofExpression(int64_t);
 
    std::string E_SgUpcElemsizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcElemsizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcElemsizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcElemsizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1185
namespace stringify {
    const char* E_SgTypeIdOp(int64_t);
 
    std::string E_SgTypeIdOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeIdOp();
}
 
namespace Rose {
    std::string stringifyE_SgTypeIdOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeIdOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1188
namespace stringify {
    const char* E_SgConditionalExp(int64_t);
 
    std::string E_SgConditionalExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConditionalExp();
}
 
namespace Rose {
    std::string stringifyE_SgConditionalExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConditionalExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1191
namespace stringify {
    const char* E_SgNewExp(int64_t);
 
    std::string E_SgNewExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNewExp();
}
 
namespace Rose {
    std::string stringifyE_SgNewExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNewExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1194
namespace stringify {
    const char* E_SgDeleteExp(int64_t);
 
    std::string E_SgDeleteExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeleteExp();
}
 
namespace Rose {
    std::string stringifyE_SgDeleteExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeleteExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1197
namespace stringify {
    const char* E_SgAggregateInitializer(int64_t);
 
    std::string E_SgAggregateInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAggregateInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgAggregateInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAggregateInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1200
namespace stringify {
    const char* E_SgCompoundInitializer(int64_t);
 
    std::string E_SgCompoundInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCompoundInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgCompoundInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCompoundInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1203
namespace stringify {
    const char* E_SgConstructorInitializer(int64_t);
 
    std::string E_SgConstructorInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConstructorInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgConstructorInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConstructorInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1206
namespace stringify {
    const char* E_SgAssignInitializer(int64_t);
 
    std::string E_SgAssignInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgAssignInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1209
namespace stringify {
    const char* E_SgDesignatedInitializer(int64_t);
 
    std::string E_SgDesignatedInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDesignatedInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgDesignatedInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDesignatedInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1212
namespace stringify {
    const char* E_SgBracedInitializer(int64_t);
 
    std::string E_SgBracedInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBracedInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgBracedInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBracedInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1215
namespace stringify {
    const char* E_SgVarArgStartOp(int64_t);
 
    std::string E_SgVarArgStartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgStartOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgStartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgStartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1218
namespace stringify {
    const char* E_SgVarArgOp(int64_t);
 
    std::string E_SgVarArgOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1221
namespace stringify {
    const char* E_SgVarArgEndOp(int64_t);
 
    std::string E_SgVarArgEndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgEndOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgEndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgEndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1224
namespace stringify {
    const char* E_SgVarArgCopyOp(int64_t);
 
    std::string E_SgVarArgCopyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgCopyOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgCopyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgCopyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1227
namespace stringify {
    const char* E_SgVarArgStartOneOperandOp(int64_t);
 
    std::string E_SgVarArgStartOneOperandOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgStartOneOperandOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgStartOneOperandOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgStartOneOperandOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1230
namespace stringify {
    const char* E_SgSubscriptExpression(int64_t);
 
    std::string E_SgSubscriptExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSubscriptExpression();
}
 
namespace Rose {
    std::string stringifyE_SgSubscriptExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSubscriptExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1233
namespace stringify {
    const char* E_SgImpliedDo(int64_t);
 
    std::string E_SgImpliedDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImpliedDo();
}
 
namespace Rose {
    std::string stringifyE_SgImpliedDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImpliedDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1236
namespace stringify {
    const char* E_SgIOItemExpression(int64_t);
 
    std::string E_SgIOItemExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIOItemExpression();
}
 
namespace Rose {
    std::string stringifyE_SgIOItemExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIOItemExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1239
namespace stringify {
    const char* E_SgStatementExpression(int64_t);
 
    std::string E_SgStatementExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStatementExpression();
}
 
namespace Rose {
    std::string stringifyE_SgStatementExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStatementExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1242
namespace stringify {
    const char* E_SgAsmOp(int64_t);
 
    std::string E_SgAsmOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmOp();
}
 
namespace Rose {
    std::string stringifyE_SgAsmOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1245
namespace stringify {
    const char* E_SgActualArgumentExpression(int64_t);
 
    std::string E_SgActualArgumentExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgActualArgumentExpression();
}
 
namespace Rose {
    std::string stringifyE_SgActualArgumentExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgActualArgumentExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1248
namespace stringify {
    const char* E_SgUnknownArrayOrFunctionReference(int64_t);
 
    std::string E_SgUnknownArrayOrFunctionReference(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnknownArrayOrFunctionReference();
}
 
namespace Rose {
    std::string stringifyE_SgUnknownArrayOrFunctionReference(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnknownArrayOrFunctionReference();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1251
namespace stringify {
    const char* E_SgCAFCoExpression(int64_t);
 
    std::string E_SgCAFCoExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCAFCoExpression();
}
 
namespace Rose {
    std::string stringifyE_SgCAFCoExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCAFCoExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1254
namespace stringify {
    const char* E_SgCudaKernelExecConfig(int64_t);
 
    std::string E_SgCudaKernelExecConfig(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCudaKernelExecConfig();
}
 
namespace Rose {
    std::string stringifyE_SgCudaKernelExecConfig(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCudaKernelExecConfig();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1257
namespace stringify {
    const char* E_SgLambdaRefExp(int64_t);
 
    std::string E_SgLambdaRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1260
namespace stringify {
    const char* E_SgDictionaryExp(int64_t);
 
    std::string E_SgDictionaryExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDictionaryExp();
}
 
namespace Rose {
    std::string stringifyE_SgDictionaryExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDictionaryExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1263
namespace stringify {
    const char* E_SgKeyDatumPair(int64_t);
 
    std::string E_SgKeyDatumPair(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgKeyDatumPair();
}
 
namespace Rose {
    std::string stringifyE_SgKeyDatumPair(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgKeyDatumPair();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1266
namespace stringify {
    const char* E_SgComprehension(int64_t);
 
    std::string E_SgComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1269
namespace stringify {
    const char* E_SgListComprehension(int64_t);
 
    std::string E_SgListComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgListComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgListComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgListComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1272
namespace stringify {
    const char* E_SgSetComprehension(int64_t);
 
    std::string E_SgSetComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSetComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgSetComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSetComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1275
namespace stringify {
    const char* E_SgDictionaryComprehension(int64_t);
 
    std::string E_SgDictionaryComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDictionaryComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgDictionaryComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDictionaryComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1278
namespace stringify {
    const char* E_SgNaryBooleanOp(int64_t);
 
    std::string E_SgNaryBooleanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryBooleanOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryBooleanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryBooleanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1281
namespace stringify {
    const char* E_SgNaryComparisonOp(int64_t);
 
    std::string E_SgNaryComparisonOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryComparisonOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryComparisonOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryComparisonOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1284
namespace stringify {
    const char* E_SgNaryOp(int64_t);
 
    std::string E_SgNaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1287
namespace stringify {
    const char* E_SgStringConversion(int64_t);
 
    std::string E_SgStringConversion(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStringConversion();
}
 
namespace Rose {
    std::string stringifyE_SgStringConversion(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStringConversion();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1290
namespace stringify {
    const char* E_SgYieldExpression(int64_t);
 
    std::string E_SgYieldExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgYieldExpression();
}
 
namespace Rose {
    std::string stringifyE_SgYieldExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgYieldExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1293
namespace stringify {
    const char* E_SgAlignOfOp(int64_t);
 
    std::string E_SgAlignOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAlignOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgAlignOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAlignOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1296
namespace stringify {
    const char* E_SgRangeExp(int64_t);
 
    std::string E_SgRangeExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRangeExp();
}
 
namespace Rose {
    std::string stringifyE_SgRangeExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRangeExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1299
namespace stringify {
    const char* E_SgFunctionParameterRefExp(int64_t);
 
    std::string E_SgFunctionParameterRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1302
namespace stringify {
    const char* E_SgLambdaExp(int64_t);
 
    std::string E_SgLambdaExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaExp();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1305
namespace stringify {
    const char* E_SgNoexceptOp(int64_t);
 
    std::string E_SgNoexceptOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNoexceptOp();
}
 
namespace Rose {
    std::string stringifyE_SgNoexceptOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNoexceptOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1308
namespace stringify {
    const char* E_SgFoldExpression(int64_t);
 
    std::string E_SgFoldExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFoldExpression();
}
 
namespace Rose {
    std::string stringifyE_SgFoldExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFoldExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1311
namespace stringify {
    const char* E_SgAwaitExpression(int64_t);
 
    std::string E_SgAwaitExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAwaitExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAwaitExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAwaitExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1314
namespace stringify {
    const char* E_SgChooseExpression(int64_t);
 
    std::string E_SgChooseExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgChooseExpression();
}
 
namespace Rose {
    std::string stringifyE_SgChooseExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgChooseExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1317
namespace stringify {
    const char* E_SgNonrealSymbol(int64_t);
 
    std::string E_SgNonrealSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1320
namespace stringify {
    const char* E_SgTemplateMemberFunctionSymbol(int64_t);
 
    std::string E_SgTemplateMemberFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateMemberFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateMemberFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateMemberFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1323
namespace stringify {
    const char* E_SgMemberFunctionSymbol(int64_t);
 
    std::string E_SgMemberFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1326
namespace stringify {
    const char* E_SgTemplateFunctionSymbol(int64_t);
 
    std::string E_SgTemplateFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1329
namespace stringify {
    const char* E_SgRenameSymbol(int64_t);
 
    std::string E_SgRenameSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRenameSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgRenameSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRenameSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1332
namespace stringify {
    const char* E_SgFunctionSymbol(int64_t);
 
    std::string E_SgFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1335
namespace stringify {
    const char* E_SgTemplateClassSymbol(int64_t);
 
    std::string E_SgTemplateClassSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1338
namespace stringify {
    const char* E_SgClassSymbol(int64_t);
 
    std::string E_SgClassSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgClassSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1341
namespace stringify {
    const char* E_SgTemplateSymbol(int64_t);
 
    std::string E_SgTemplateSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1344
namespace stringify {
    const char* E_SgEnumSymbol(int64_t);
 
    std::string E_SgEnumSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgEnumSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1347
namespace stringify {
    const char* E_SgTemplateTypedefSymbol(int64_t);
 
    std::string E_SgTemplateTypedefSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateTypedefSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateTypedefSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateTypedefSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1350
namespace stringify {
    const char* E_SgTypedefSymbol(int64_t);
 
    std::string E_SgTypedefSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1353
namespace stringify {
    const char* E_SgLabelSymbol(int64_t);
 
    std::string E_SgLabelSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLabelSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgLabelSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLabelSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1356
namespace stringify {
    const char* E_SgNamespaceSymbol(int64_t);
 
    std::string E_SgNamespaceSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1359
namespace stringify {
    const char* E_SgModuleSymbol(int64_t);
 
    std::string E_SgModuleSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModuleSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgModuleSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModuleSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// -build/src/frontend/SageIII/Cxx_GrammarTreeTraversalAccessEnums.h line 1362
namespace stringify {
    const char* E_SgAliasSymbol(int64_t);
 
    std::string E_SgAliasSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAliasSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAliasSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAliasSymbol();
}
 
namespace stringify {
    namespace TransformationSupport {
    }
    namespace Rose {
        namespace CommandLine {
            namespace FailedAssertionBehaviorAdjuster {
            }
            namespace SuffixMultiplierParser {
            }
        }
        namespace builder {
        }
        namespace StringUtility {
        }
        namespace Yaml {
            namespace Exception {
            }
            namespace Iterator {
            }
            namespace ConstIterator {
            }
            namespace Node {
            }
            namespace ReaderLine {
            }
        }
        namespace CodeGen {
        }
        namespace Color {
            namespace Enabled {
            }
            namespace Theme {
            }
            namespace Layer {
            }
        }
        namespace AST {
            namespace cmdline {
                namespace graphviz_t {
                }
                namespace checker_t {
                }
            }
            namespace Defects {
            }
        }
        namespace FormattedTable {
        }
        namespace EditDistance {
            namespace TreeEditDistance {
            }
        }
        namespace Snippet {
        }
    }
    namespace a_type_wrapper {
    }
    namespace a_class_type_wrapper {
    }
    namespace a_type_indirection {
    }
    namespace an_array_type_wrapper {
    }
    namespace an_accessibility {
    }
    namespace a_type_definition {
    }
    namespace __cxxabiv1 {
        namespace __base_class_type_info {
        }
        namespace __vmi_class_type_info {
        }
        namespace __pbase_type_info {
        }
    }
    namespace an_ifc_module {
    }
    namespace ClangToSageTranslator {
    }
    namespace ClangToDotTranslator {
        namespace ClangToDotTranslator {
        }
    }
    namespace LanguageTranslation {
    }
    namespace ROSE_Fortran_defs {
    }
    namespace SageBuilder {
    }
    namespace SageInterface {
        namespace DeferredTransformation {
        }
    }
    namespace PreprocessingInfo {
    }
    namespace ROSEAttributesList {
    }
    namespace ROSE_token_ids {
    }
    namespace OmpSupport {
    }
    namespace AST_Graph {
    }
    namespace AstAttributeDOT {
    }
    namespace DOTGraphNode {
    }
    namespace DOTGraphEdge {
    }
    namespace VirtualCFG {
    }
    namespace AstNodeClass {
    }
    namespace Sawyer {
        namespace CommandLine {
            namespace Parser {
            }
        }
        namespace Language {
            namespace Clexer {
            }
        }
        namespace Container {
            namespace Graph {
            }
            namespace Algorithm {
            }
        }
        namespace Document {
            namespace Markup {
            }
        }
        namespace Access {
        }
        namespace Message {
            namespace Prefix {
            }
        }
        namespace Tree {
            namespace Node {
            }
        }
    }
    namespace UnparseLanguageIndependentConstructs {
    }
    namespace Unparse_ExprStmt {
    }
    namespace Unparser {
    }
    namespace AstUnparseAttribute {
    }
    namespace nlohmann {
        namespace detail {
            namespace lexer_base {
            }
        }
        namespace basic_json {
        }
    }
    namespace DOTGeneration {
    }
    namespace AbstractMemoryObject {
        namespace IndexSet {
        }
    }
    namespace FunctionCallInfo {
    }
    namespace MidLevelCollectionTypedefs {
    }
    namespace HighLevelCollectionTypedefs {
    }
    namespace AstAttribute {
    }
    namespace SDG {
        namespace SDGNode {
        }
        namespace SDGEdge {
        }
        namespace PDGEdge {
        }
    }
    namespace ConstrGraph {
    }
    namespace TaintLattice {
    }
    namespace CGFunction {
        namespace iterator {
        }
    }
    namespace DominatorTreesAndDominanceFrontiers {
        namespace DominatorTree {
        }
    }
    namespace ssa_unfiltered_cfg {
        namespace ReachingDef {
        }
    }
    namespace CallGraph {
    }
    namespace CFG {
    }
    namespace RIFG {
    }
    namespace BaseGraph {
        namespace BiDirNodesIterator {
        }
    }
    namespace ArithmeticIntensityMeasurement {
    }
    namespace ReachingDef {
    }
    namespace CollectAliasRelations {
    }
    namespace PtrAliasAnalysis {
    }
    namespace MatchStatus {
    }
    namespace CodeThorn {
        namespace VariableIdMapping {
        }
        namespace LabelProperty {
        }
    }
    namespace SgNodeHelper {
        namespace Pattern {
            namespace OutputTarget {
            }
        }
    }
    namespace BooleanQuery {
    }
    namespace NameQuery {
    }
    namespace AstQueryNamespace {
    }
    namespace NumberQuery {
    }
    namespace NodeQuery {
    }
    namespace SgConstVolatileModifier {
    }
    namespace SgStorageModifier {
    }
    namespace SgAccessModifier {
    }
    namespace SgFunctionModifier {
    }
    namespace SgUPC_AccessModifier {
    }
    namespace SgSpecialFunctionModifier {
    }
    namespace SgElaboratedTypeModifier {
    }
    namespace SgLinkageModifier {
    }
    namespace SgBaseClassModifier {
    }
    namespace SgStructureModifier {
    }
    namespace SgTypeModifier {
    }
    namespace SgDeclarationModifier {
    }
    namespace SgOpenclAccessModeModifier {
    }
    namespace Sg_File_Info {
    }
    namespace SgFile {
    }
    namespace SgProject {
    }
    namespace SgUnparse_Info {
    }
    namespace SgTemplateParameter {
    }
    namespace SgTemplateArgument {
    }
    namespace SgGraph {
    }
    namespace SgDataStatementValue {
    }
    namespace SgType {
    }
    namespace SgModifierType {
    }
    namespace SgMemberFunctionType {
    }
    namespace SgLocatedNode {
    }
    namespace SgToken {
    }
    namespace SgInitializedName {
    }
    namespace SgOmpClause {
    }
    namespace SgForAllStatement {
    }
    namespace SgDeclarationStatement {
    }
    namespace SgVariableDeclaration {
    }
    namespace SgAttributeSpecificationStatement {
    }
    namespace SgTemplateDeclaration {
    }
    namespace SgInterfaceStatement {
    }
    namespace SgClassDeclaration {
    }
    namespace SgTemplateClassDeclaration {
    }
    namespace SgImplicitStatement {
    }
    namespace SgProcedureHeaderStatement {
    }
    namespace SgProcessControlStatement {
    }
    namespace SgIOStatement {
    }
    namespace SgImageControlStatement {
    }
    namespace SgUnaryOp {
    }
    namespace SgCastExp {
    }
    namespace SgThrowOp {
    }
    namespace SgAsmOp {
    }
    namespace SgLabelSymbol {
    }
}
 
#endif